components/search_engines/template_url.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/search_engines/template_url.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/command_line.h"
  12 #include "base/format_macros.h"
  13 #include "base/i18n/icu_string_conversions.h"
  14 #include "base/i18n/rtl.h"
  15 #include "base/logging.h"
  16 #include "base/metrics/field_trial.h"
  17 #include "base/rand_util.h"
  18 #include "base/strings/string_number_conversions.h"
  19 #include "base/strings/string_split.h"
  20 #include "base/strings/string_util.h"
  21 #include "base/strings/stringprintf.h"
  22 #include "base/strings/utf_string_conversions.h"
  23 #include "components/google/core/browser/google_util.h"
  24 #include "components/metrics/proto/omnibox_input_type.pb.h"
  25 #include "components/search_engines/search_engines_switches.h"
  26 #include "components/search_engines/search_terms_data.h"
  27 #include "google_apis/google_api_keys.h"
  28 #include "net/base/escape.h"
  29 #include "net/base/mime_util.h"
  30 #include "net/base/net_util.h"
  31
  32 namespace {
  33
  34 // The TemplateURLRef has any number of terms that need to be replaced. Each of
  35 // the terms is enclosed in braces. If the character preceeding the final
  36 // brace is a ?, it indicates the term is optional and can be replaced with
  37 // an empty string.
  38 const char kStartParameter = '{';
  39 const char kEndParameter = '}';
  40 const char kOptional = '?';
  41
  42 // Known parameters found in the URL.
  43 const char kSearchTermsParameter[] = "searchTerms";
  44 const char kSearchTermsParameterFull[] = "{searchTerms}";
  45 const char kCountParameter[] = "count";
  46 const char kStartIndexParameter[] = "startIndex";
  47 const char kStartPageParameter[] = "startPage";
  48 const char kLanguageParameter[] = "language";
  49 const char kInputEncodingParameter[] = "inputEncoding";
  50 const char kOutputEncodingParameter[] = "outputEncoding";
  51
  52 const char kGoogleAssistedQueryStatsParameter[] = "google:assistedQueryStats";
  53
  54 // Host/Domain Google searches are relative to.
  55 const char kGoogleBaseURLParameter[] = "google:baseURL";
  56 const char kGoogleBaseURLParameterFull[] = "{google:baseURL}";
  57
  58 // Like google:baseURL, but for the Search Suggest capability.
  59 const char kGoogleBaseSuggestURLParameter[] = "google:baseSuggestURL";
  60 const char kGoogleBaseSuggestURLParameterFull[] = "{google:baseSuggestURL}";
  61 const char kGoogleBookmarkBarPinnedParameter[] = "google:bookmarkBarPinned";
  62 const char kGoogleContextualSearchContextData[] =
  63     "google:contextualSearchContextData";
  64 const char kGoogleContextualSearchVersion[] = "google:contextualSearchVersion";
  65 const char kGoogleCurrentPageUrlParameter[] = "google:currentPageUrl";
  66 const char kGoogleCursorPositionParameter[] = "google:cursorPosition";
  67 const char kGoogleForceInstantResultsParameter[] = "google:forceInstantResults";
  68 const char kGoogleImageSearchSource[] = "google:imageSearchSource";
  69 const char kGoogleImageThumbnailParameter[] = "google:imageThumbnail";
  70 const char kGoogleImageOriginalWidth[] = "google:imageOriginalWidth";
  71 const char kGoogleImageOriginalHeight[] = "google:imageOriginalHeight";
  72 const char kGoogleImageURLParameter[] = "google:imageURL";
  73 const char kGoogleInputTypeParameter[] = "google:inputType";
  74 const char kGoogleInstantExtendedEnabledParameter[] =
  75     "google:instantExtendedEnabledParameter";
  76 const char kGoogleInstantExtendedEnabledKey[] =
  77     "google:instantExtendedEnabledKey";
  78 const char kGoogleInstantExtendedEnabledKeyFull[] =
  79     "{google:instantExtendedEnabledKey}";
  80 const char kGoogleNTPIsThemedParameter[] = "google:ntpIsThemedParameter";
  81 const char kGoogleOmniboxStartMarginParameter[] =
  82     "google:omniboxStartMarginParameter";
  83 const char kGoogleOriginalQueryForSuggestionParameter[] =
  84     "google:originalQueryForSuggestion";
  85 const char kGooglePageClassificationParameter[] = "google:pageClassification";
  86 const char kGooglePrefetchQuery[] = "google:prefetchQuery";
  87 const char kGoogleRLZParameter[] = "google:RLZ";
  88 const char kGoogleSearchClient[] = "google:searchClient";
  89 const char kGoogleSearchFieldtrialParameter[] =
  90     "google:searchFieldtrialParameter";
  91 const char kGoogleSearchVersion[] = "google:searchVersion";
  92 const char kGoogleSessionToken[] = "google:sessionToken";
  93 const char kGoogleSourceIdParameter[] = "google:sourceId";
  94 const char kGoogleSuggestAPIKeyParameter[] = "google:suggestAPIKeyParameter";
  95 const char kGoogleSuggestClient[] = "google:suggestClient";
  96 const char kGoogleSuggestRequestId[] = "google:suggestRid";
  97
  98 // Same as kSearchTermsParameter, with no escaping.
  99 const char kGoogleUnescapedSearchTermsParameter[] =
 100     "google:unescapedSearchTerms";
 101 const char kGoogleUnescapedSearchTermsParameterFull[] =
 102     "{google:unescapedSearchTerms}";
 103
 104 // Display value for kSearchTermsParameter.
 105 const char kDisplaySearchTerms[] = "%s";
 106
 107 // Display value for kGoogleUnescapedSearchTermsParameter.
 108 const char kDisplayUnescapedSearchTerms[] = "%S";
 109
 110 // Used if the count parameter is not optional. Indicates we want 10 search
 111 // results.
 112 const char kDefaultCount[] = "10";
 113
 114 // Used if the parameter kOutputEncodingParameter is required.
 115 const char kOutputEncodingType[] = "UTF-8";
 116
 117 // Attempts to encode |terms| and |original_query| in |encoding| and escape
 118 // them.  |terms| may be escaped as path or query depending on |is_in_query|;
 119 // |original_query| is always escaped as query.  Returns whether the encoding
 120 // process succeeded.
 121 bool TryEncoding(const base::string16& terms,
 122                  const base::string16& original_query,
 123                  const char* encoding,
 124                  bool is_in_query,
 125                  base::string16* escaped_terms,
 126                  base::string16* escaped_original_query) {
 127   DCHECK(escaped_terms);
 128   DCHECK(escaped_original_query);
 129   std::string encoded_terms;
 130   if (!base::UTF16ToCodepage(terms, encoding,
 131       base::OnStringConversionError::SKIP, &encoded_terms))
 132     return false;
 133   *escaped_terms = base::UTF8ToUTF16(is_in_query ?
 134       net::EscapeQueryParamValue(encoded_terms, true) :
 135       net::EscapePath(encoded_terms));
 136   if (original_query.empty())
 137     return true;
 138   std::string encoded_original_query;
 139   if (!base::UTF16ToCodepage(original_query, encoding,
 140       base::OnStringConversionError::SKIP, &encoded_original_query))
 141     return false;
 142   *escaped_original_query = base::UTF8ToUTF16(
 143       net::EscapeQueryParamValue(encoded_original_query, true));
 144   return true;
 145 }
 146
 147 // Extract query key and host given a list of parameters coming from the URL
 148 // query or ref.
 149 std::string FindSearchTermsKey(const std::string& params) {
 150   if (params.empty())
 151     return std::string();
 152   url::Component query, key, value;
 153   query.len = static_cast<int>(params.size());
 154   while (url::ExtractQueryKeyValue(params.c_str(), &query, &key, &value)) {
 155     if (key.is_nonempty() && value.is_nonempty()) {
 156       std::string value_string = params.substr(value.begin, value.len);
 157       if (value_string.find(kSearchTermsParameterFull, 0) !=
 158           std::string::npos ||
 159           value_string.find(kGoogleUnescapedSearchTermsParameterFull, 0) !=
 160           std::string::npos) {
 161         return params.substr(key.begin, key.len);
 162       }
 163     }
 164   }
 165   return std::string();
 166 }
 167
 168 bool IsTemplateParameterString(const std::string& param) {
 169   return (param.length() > 2) && (*(param.begin()) == kStartParameter) &&
 170       (*(param.rbegin()) == kEndParameter);
 171 }
 172
 173 }  // namespace
 174
 175
 176 // TemplateURLRef::SearchTermsArgs --------------------------------------------
 177
 178 TemplateURLRef::SearchTermsArgs::SearchTermsArgs(
 179     const base::string16& search_terms)
 180     : search_terms(search_terms),
 181       input_type(metrics::OmniboxInputType::INVALID),
 182       accepted_suggestion(NO_SUGGESTIONS_AVAILABLE),
 183       cursor_position(base::string16::npos),
 184       enable_omnibox_start_margin(false),
 185       page_classification(metrics::OmniboxEventProto::INVALID_SPEC),
 186       bookmark_bar_pinned(false),
 187       append_extra_query_params(false),
 188       force_instant_results(false),
 189       from_app_list(false),
 190       contextual_search_params(ContextualSearchParams()) {
 191 }
 192
 193 TemplateURLRef::SearchTermsArgs::~SearchTermsArgs() {
 194 }
 195
 196 TemplateURLRef::SearchTermsArgs::ContextualSearchParams::
 197     ContextualSearchParams()
 198     : version(-1),
 199       start(base::string16::npos),
 200       end(base::string16::npos),
 201       resolve(true) {
 202 }
 203
 204 TemplateURLRef::SearchTermsArgs::ContextualSearchParams::
 205     ContextualSearchParams(
 206         const int version,
 207         const size_t start,
 208         const size_t end,
 209         const std::string& selection,
 210         const std::string& content,
 211         const std::string& base_page_url,
 212         const std::string& encoding)
 213     : version(version),
 214       start(start),
 215       end(end),
 216       selection(selection),
 217       content(content),
 218       base_page_url(base_page_url),
 219       encoding(encoding),
 220       resolve(true) {
 221 }
 222
 223 TemplateURLRef::SearchTermsArgs::ContextualSearchParams::
 224     ContextualSearchParams(
 225         const int version,
 226         const size_t start,
 227         const size_t end,
 228         const std::string& selection,
 229         const std::string& content,
 230         const std::string& base_page_url,
 231         const std::string& encoding,
 232         const bool resolve)
 233     : version(version),
 234       start(start),
 235       end(end),
 236       selection(selection),
 237       content(content),
 238       base_page_url(base_page_url),
 239       encoding(encoding),
 240       resolve(resolve) {
 241 }
 242
 243 TemplateURLRef::SearchTermsArgs::ContextualSearchParams::
 244     ~ContextualSearchParams() {
 245 }
 246
 247 // TemplateURLRef -------------------------------------------------------------
 248
 249 TemplateURLRef::TemplateURLRef(TemplateURL* owner, Type type)
 250     : owner_(owner),
 251       type_(type),
 252       index_in_owner_(0),
 253       parsed_(false),
 254       valid_(false),
 255       supports_replacements_(false),
 256       search_term_key_location_(url::Parsed::QUERY),
 257       prepopulated_(false) {
 258   DCHECK(owner_);
 259   DCHECK_NE(INDEXED, type_);
 260 }
 261
 262 TemplateURLRef::TemplateURLRef(TemplateURL* owner, size_t index_in_owner)
 263     : owner_(owner),
 264       type_(INDEXED),
 265       index_in_owner_(index_in_owner),
 266       parsed_(false),
 267       valid_(false),
 268       supports_replacements_(false),
 269       search_term_key_location_(url::Parsed::QUERY),
 270       prepopulated_(false) {
 271   DCHECK(owner_);
 272   DCHECK_LT(index_in_owner_, owner_->URLCount());
 273 }
 274
 275 TemplateURLRef::~TemplateURLRef() {
 276 }
 277
 278 std::string TemplateURLRef::GetURL() const {
 279   switch (type_) {
 280     case SEARCH:            return owner_->url();
 281     case SUGGEST:           return owner_->suggestions_url();
 282     case INSTANT:           return owner_->instant_url();
 283     case IMAGE:             return owner_->image_url();
 284     case NEW_TAB:           return owner_->new_tab_url();
 285     case CONTEXTUAL_SEARCH: return owner_->contextual_search_url();
 286     case INDEXED:           return owner_->GetURL(index_in_owner_);
 287     default:       NOTREACHED(); return std::string();  // NOLINT
 288   }
 289 }
 290
 291 std::string TemplateURLRef::GetPostParamsString() const {
 292   switch (type_) {
 293     case INDEXED:
 294     case SEARCH:            return owner_->search_url_post_params();
 295     case SUGGEST:           return owner_->suggestions_url_post_params();
 296     case INSTANT:           return owner_->instant_url_post_params();
 297     case NEW_TAB:           return std::string();
 298     case CONTEXTUAL_SEARCH: return std::string();
 299     case IMAGE:             return owner_->image_url_post_params();
 300     default:      NOTREACHED(); return std::string();  // NOLINT
 301   }
 302 }
 303
 304 bool TemplateURLRef::UsesPOSTMethod(
 305     const SearchTermsData& search_terms_data) const {
 306   ParseIfNecessary(search_terms_data);
 307   return !post_params_.empty();
 308 }
 309
 310 bool TemplateURLRef::EncodeFormData(const PostParams& post_params,
 311                                     PostContent* post_content) const {
 312   if (post_params.empty())
 313     return true;
 314   if (!post_content)
 315     return false;
 316
 317   const char kUploadDataMIMEType[] = "multipart/form-data; boundary=";
 318   const char kMultipartBoundary[] = "----+*+----%016" PRIx64 "----+*+----";
 319   // Each name/value pair is stored in a body part which is preceded by a
 320   // boundary delimiter line. Uses random number generator here to create
 321   // a unique boundary delimiter for form data encoding.
 322   std::string boundary = base::StringPrintf(kMultipartBoundary,
 323                                             base::RandUint64());
 324   // Sets the content MIME type.
 325   post_content->first = kUploadDataMIMEType;
 326   post_content->first += boundary;
 327   // Encodes the post parameters.
 328   std::string* post_data = &post_content->second;
 329   post_data->clear();
 330   for (PostParams::const_iterator param = post_params.begin();
 331        param != post_params.end(); ++param) {
 332     DCHECK(!param->first.empty());
 333     net::AddMultipartValueForUpload(param->first, param->second, boundary,
 334                                     std::string(), post_data);
 335   }
 336   net::AddMultipartFinalDelimiterForUpload(boundary, post_data);
 337   return true;
 338 }
 339
 340 bool TemplateURLRef::SupportsReplacement(
 341     const SearchTermsData& search_terms_data) const {
 342   ParseIfNecessary(search_terms_data);
 343   return valid_ && supports_replacements_;
 344 }
 345
 346 std::string TemplateURLRef::ReplaceSearchTerms(
 347     const SearchTermsArgs& search_terms_args,
 348     const SearchTermsData& search_terms_data,
 349     PostContent* post_content) const {
 350   ParseIfNecessary(search_terms_data);
 351   if (!valid_)
 352     return std::string();
 353
 354   std::string url(HandleReplacements(search_terms_args, search_terms_data,
 355                                      post_content));
 356
 357   GURL gurl(url);
 358   if (!gurl.is_valid())
 359     return url;
 360
 361   std::vector<std::string> query_params;
 362   if (search_terms_args.append_extra_query_params) {
 363     std::string extra_params(
 364         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
 365             switches::kExtraSearchQueryParams));
 366     if (!extra_params.empty())
 367       query_params.push_back(extra_params);
 368   }
 369   if (!search_terms_args.suggest_query_params.empty())
 370     query_params.push_back(search_terms_args.suggest_query_params);
 371   if (!gurl.query().empty())
 372     query_params.push_back(gurl.query());
 373
 374   if (query_params.empty())
 375     return url;
 376
 377   GURL::Replacements replacements;
 378   std::string query_str = JoinString(query_params, "&");
 379   replacements.SetQueryStr(query_str);
 380   return gurl.ReplaceComponents(replacements).possibly_invalid_spec();
 381 }
 382
 383 bool TemplateURLRef::IsValid(const SearchTermsData& search_terms_data) const {
 384   ParseIfNecessary(search_terms_data);
 385   return valid_;
 386 }
 387
 388 base::string16 TemplateURLRef::DisplayURL(
 389     const SearchTermsData& search_terms_data) const {
 390   ParseIfNecessary(search_terms_data);
 391   base::string16 result(base::UTF8ToUTF16(GetURL()));
 392   if (valid_ && !replacements_.empty()) {
 393     ReplaceSubstringsAfterOffset(&result, 0,
 394                                  base::ASCIIToUTF16(kSearchTermsParameterFull),
 395                                  base::ASCIIToUTF16(kDisplaySearchTerms));
 396     ReplaceSubstringsAfterOffset(&result, 0,
 397         base::ASCIIToUTF16(kGoogleUnescapedSearchTermsParameterFull),
 398         base::ASCIIToUTF16(kDisplayUnescapedSearchTerms));
 399   }
 400   return result;
 401 }
 402
 403 // static
 404 std::string TemplateURLRef::DisplayURLToURLRef(
 405     const base::string16& display_url) {
 406   base::string16 result = display_url;
 407   ReplaceSubstringsAfterOffset(&result, 0,
 408                                base::ASCIIToUTF16(kDisplaySearchTerms),
 409                                base::ASCIIToUTF16(kSearchTermsParameterFull));
 410   ReplaceSubstringsAfterOffset(
 411       &result, 0,
 412       base::ASCIIToUTF16(kDisplayUnescapedSearchTerms),
 413       base::ASCIIToUTF16(kGoogleUnescapedSearchTermsParameterFull));
 414   return base::UTF16ToUTF8(result);
 415 }
 416
 417 const std::string& TemplateURLRef::GetHost(
 418     const SearchTermsData& search_terms_data) const {
 419   ParseIfNecessary(search_terms_data);
 420   return host_;
 421 }
 422
 423 const std::string& TemplateURLRef::GetPath(
 424     const SearchTermsData& search_terms_data) const {
 425   ParseIfNecessary(search_terms_data);
 426   return path_;
 427 }
 428
 429 const std::string& TemplateURLRef::GetSearchTermKey(
 430     const SearchTermsData& search_terms_data) const {
 431   ParseIfNecessary(search_terms_data);
 432   return search_term_key_;
 433 }
 434
 435 base::string16 TemplateURLRef::SearchTermToString16(
 436     const std::string& term) const {
 437   const std::vector<std::string>& encodings = owner_->input_encodings();
 438   base::string16 result;
 439
 440   std::string unescaped = net::UnescapeURLComponent(
 441       term,
 442       net::UnescapeRule::REPLACE_PLUS_WITH_SPACE |
 443       net::UnescapeRule::URL_SPECIAL_CHARS);
 444   for (size_t i = 0; i < encodings.size(); ++i) {
 445     if (base::CodepageToUTF16(unescaped, encodings[i].c_str(),
 446                               base::OnStringConversionError::FAIL, &result))
 447       return result;
 448   }
 449
 450   // Always fall back on UTF-8 if it works.
 451   if (base::CodepageToUTF16(unescaped, base::kCodepageUTF8,
 452                             base::OnStringConversionError::FAIL, &result))
 453     return result;
 454
 455   // When nothing worked, just use the escaped text. We have no idea what the
 456   // encoding is. We need to substitute spaces for pluses ourselves since we're
 457   // not sending it through an unescaper.
 458   result = base::UTF8ToUTF16(term);
 459   std::replace(result.begin(), result.end(), '+', ' ');
 460   return result;
 461 }
 462
 463 bool TemplateURLRef::HasGoogleBaseURLs(
 464     const SearchTermsData& search_terms_data) const {
 465   ParseIfNecessary(search_terms_data);
 466   for (size_t i = 0; i < replacements_.size(); ++i) {
 467     if ((replacements_[i].type == GOOGLE_BASE_URL) ||
 468         (replacements_[i].type == GOOGLE_BASE_SUGGEST_URL))
 469       return true;
 470   }
 471   return false;
 472 }
 473
 474 bool TemplateURLRef::ExtractSearchTermsFromURL(
 475     const GURL& url,
 476     base::string16* search_terms,
 477     const SearchTermsData& search_terms_data,
 478     url::Parsed::ComponentType* search_terms_component,
 479     url::Component* search_terms_position) const {
 480   DCHECK(search_terms);
 481   search_terms->clear();
 482
 483   ParseIfNecessary(search_terms_data);
 484
 485   // We need a search term in the template URL to extract something.
 486   if (search_term_key_.empty())
 487     return false;
 488
 489   // TODO(beaudoin): Support patterns of the form http://foo/{searchTerms}/
 490   // See crbug.com/153798
 491
 492   // Fill-in the replacements. We don't care about search terms in the pattern,
 493   // so we use the empty string.
 494   // Currently we assume the search term only shows in URL, not in post params.
 495   GURL pattern(ReplaceSearchTerms(SearchTermsArgs(base::string16()),
 496                                   search_terms_data, NULL));
 497   // Host, path and port must match.
 498   if (url.port() != pattern.port() ||
 499       url.host() != host_ ||
 500       url.path() != path_) {
 501     return false;
 502   }
 503
 504   // Parameter must be present either in the query or the ref.
 505   const std::string& params(
 506       (search_term_key_location_ == url::Parsed::QUERY) ?
 507           url.query() : url.ref());
 508
 509   url::Component query, key, value;
 510   query.len = static_cast<int>(params.size());
 511   bool key_found = false;
 512   while (url::ExtractQueryKeyValue(params.c_str(), &query, &key, &value)) {
 513     if (key.is_nonempty()) {
 514       if (params.substr(key.begin, key.len) == search_term_key_) {
 515         // Fail if search term key is found twice.
 516         if (key_found) {
 517           search_terms->clear();
 518           return false;
 519         }
 520         key_found = true;
 521         // Extract the search term.
 522         *search_terms = net::UnescapeAndDecodeUTF8URLComponent(
 523             params.substr(value.begin, value.len),
 524             net::UnescapeRule::SPACES |
 525                 net::UnescapeRule::URL_SPECIAL_CHARS |
 526                 net::UnescapeRule::REPLACE_PLUS_WITH_SPACE);
 527         if (search_terms_component)
 528           *search_terms_component = search_term_key_location_;
 529         if (search_terms_position)
 530           *search_terms_position = value;
 531       }
 532     }
 533   }
 534   return key_found;
 535 }
 536
 537 void TemplateURLRef::InvalidateCachedValues() const {
 538   supports_replacements_ = valid_ = parsed_ = false;
 539   host_.clear();
 540   path_.clear();
 541   search_term_key_.clear();
 542   replacements_.clear();
 543   post_params_.clear();
 544 }
 545
 546 bool TemplateURLRef::ParseParameter(size_t start,
 547                                     size_t end,
 548                                     std::string* url,
 549                                     Replacements* replacements) const {
 550   DCHECK(start != std::string::npos &&
 551          end != std::string::npos && end > start);
 552   size_t length = end - start - 1;
 553   bool optional = false;
 554   if ((*url)[end - 1] == kOptional) {
 555     optional = true;
 556     length--;
 557   }
 558   std::string parameter(url->substr(start + 1, length));
 559   std::string full_parameter(url->substr(start, end - start + 1));
 560   // Remove the parameter from the string.  For parameters who replacement is
 561   // constant and already known, just replace them directly.  For other cases,
 562   // like parameters whose values may change over time, use |replacements|.
 563   url->erase(start, end - start + 1);
 564   if (parameter == kSearchTermsParameter) {
 565     replacements->push_back(Replacement(SEARCH_TERMS, start));
 566   } else if (parameter == kCountParameter) {
 567     if (!optional)
 568       url->insert(start, kDefaultCount);
 569   } else if (parameter == kGoogleAssistedQueryStatsParameter) {
 570     replacements->push_back(Replacement(GOOGLE_ASSISTED_QUERY_STATS, start));
 571   } else if (parameter == kGoogleBaseURLParameter) {
 572     replacements->push_back(Replacement(GOOGLE_BASE_URL, start));
 573   } else if (parameter == kGoogleBaseSuggestURLParameter) {
 574     replacements->push_back(Replacement(GOOGLE_BASE_SUGGEST_URL, start));
 575   } else if (parameter == kGoogleBookmarkBarPinnedParameter) {
 576     replacements->push_back(Replacement(GOOGLE_BOOKMARK_BAR_PINNED, start));
 577   } else if (parameter == kGoogleCurrentPageUrlParameter) {
 578     replacements->push_back(Replacement(GOOGLE_CURRENT_PAGE_URL, start));
 579   } else if (parameter == kGoogleCursorPositionParameter) {
 580     replacements->push_back(Replacement(GOOGLE_CURSOR_POSITION, start));
 581   } else if (parameter == kGoogleForceInstantResultsParameter) {
 582     replacements->push_back(Replacement(GOOGLE_FORCE_INSTANT_RESULTS, start));
 583   } else if (parameter == kGoogleImageOriginalHeight) {
 584     replacements->push_back(
 585         Replacement(TemplateURLRef::GOOGLE_IMAGE_ORIGINAL_HEIGHT, start));
 586   } else if (parameter == kGoogleImageOriginalWidth) {
 587     replacements->push_back(
 588         Replacement(TemplateURLRef::GOOGLE_IMAGE_ORIGINAL_WIDTH, start));
 589   } else if (parameter == kGoogleImageSearchSource) {
 590     replacements->push_back(
 591         Replacement(TemplateURLRef::GOOGLE_IMAGE_SEARCH_SOURCE, start));
 592   } else if (parameter == kGoogleImageThumbnailParameter) {
 593     replacements->push_back(
 594         Replacement(TemplateURLRef::GOOGLE_IMAGE_THUMBNAIL, start));
 595   } else if (parameter == kGoogleImageURLParameter) {
 596     replacements->push_back(Replacement(TemplateURLRef::GOOGLE_IMAGE_URL,
 597                                         start));
 598   } else if (parameter == kGoogleInputTypeParameter) {
 599     replacements->push_back(Replacement(TemplateURLRef::GOOGLE_INPUT_TYPE,
 600                                         start));
 601   } else if (parameter == kGoogleInstantExtendedEnabledParameter) {
 602     replacements->push_back(Replacement(GOOGLE_INSTANT_EXTENDED_ENABLED,
 603                                         start));
 604   } else if (parameter == kGoogleInstantExtendedEnabledKey) {
 605     url->insert(start, google_util::kInstantExtendedAPIParam);
 606   } else if (parameter == kGoogleNTPIsThemedParameter) {
 607     replacements->push_back(Replacement(GOOGLE_NTP_IS_THEMED, start));
 608   } else if (parameter == kGoogleOmniboxStartMarginParameter) {
 609     replacements->push_back(Replacement(GOOGLE_OMNIBOX_START_MARGIN, start));
 610   } else if (parameter == kGoogleContextualSearchVersion) {
 611     replacements->push_back(
 612         Replacement(GOOGLE_CONTEXTUAL_SEARCH_VERSION, start));
 613   } else if (parameter == kGoogleContextualSearchContextData) {
 614     replacements->push_back(
 615         Replacement(GOOGLE_CONTEXTUAL_SEARCH_CONTEXT_DATA, start));
 616   } else if (parameter == kGoogleOriginalQueryForSuggestionParameter) {
 617     replacements->push_back(Replacement(GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION,
 618                                         start));
 619   } else if (parameter == kGooglePageClassificationParameter) {
 620     replacements->push_back(Replacement(GOOGLE_PAGE_CLASSIFICATION, start));
 621   } else if (parameter == kGooglePrefetchQuery) {
 622     replacements->push_back(Replacement(GOOGLE_PREFETCH_QUERY, start));
 623   } else if (parameter == kGoogleRLZParameter) {
 624     replacements->push_back(Replacement(GOOGLE_RLZ, start));
 625   } else if (parameter == kGoogleSearchClient) {
 626     replacements->push_back(Replacement(GOOGLE_SEARCH_CLIENT, start));
 627   } else if (parameter == kGoogleSearchFieldtrialParameter) {
 628     replacements->push_back(Replacement(GOOGLE_SEARCH_FIELDTRIAL_GROUP, start));
 629   } else if (parameter == kGoogleSearchVersion) {
 630     replacements->push_back(Replacement(GOOGLE_SEARCH_VERSION, start));
 631   } else if (parameter == kGoogleSessionToken) {
 632     replacements->push_back(Replacement(GOOGLE_SESSION_TOKEN, start));
 633   } else if (parameter == kGoogleSourceIdParameter) {
 634 #if defined(OS_ANDROID)
 635     url->insert(start, "sourceid=chrome-mobile&");
 636 #else
 637     url->insert(start, "sourceid=chrome&");
 638 #endif
 639   } else if (parameter == kGoogleSuggestAPIKeyParameter) {
 640     url->insert(start,
 641                 net::EscapeQueryParamValue(google_apis::GetAPIKey(), false));
 642   } else if (parameter == kGoogleSuggestClient) {
 643     replacements->push_back(Replacement(GOOGLE_SUGGEST_CLIENT, start));
 644   } else if (parameter == kGoogleSuggestRequestId) {
 645     replacements->push_back(Replacement(GOOGLE_SUGGEST_REQUEST_ID, start));
 646   } else if (parameter == kGoogleUnescapedSearchTermsParameter) {
 647     replacements->push_back(Replacement(GOOGLE_UNESCAPED_SEARCH_TERMS, start));
 648   } else if (parameter == kInputEncodingParameter) {
 649     replacements->push_back(Replacement(ENCODING, start));
 650   } else if (parameter == kLanguageParameter) {
 651     replacements->push_back(Replacement(LANGUAGE, start));
 652   } else if (parameter == kOutputEncodingParameter) {
 653     if (!optional)
 654       url->insert(start, kOutputEncodingType);
 655   } else if ((parameter == kStartIndexParameter) ||
 656              (parameter == kStartPageParameter)) {
 657     // We don't support these.
 658     if (!optional)
 659       url->insert(start, "1");
 660   } else if (!prepopulated_) {
 661     // If it's a prepopulated URL, we know that it's safe to remove unknown
 662     // parameters, so just ignore this and return true below. Otherwise it could
 663     // be some garbage but can also be a javascript block. Put it back.
 664     url->insert(start, full_parameter);
 665     return false;
 666   }
 667   return true;
 668 }
 669
 670 std::string TemplateURLRef::ParseURL(const std::string& url,
 671                                      Replacements* replacements,
 672                                      PostParams* post_params,
 673                                      bool* valid) const {
 674   *valid = false;
 675   std::string parsed_url = url;
 676   for (size_t last = 0; last != std::string::npos; ) {
 677     last = parsed_url.find(kStartParameter, last);
 678     if (last != std::string::npos) {
 679       size_t template_end = parsed_url.find(kEndParameter, last);
 680       if (template_end != std::string::npos) {
 681         // Since we allow Javascript in the URL, {} pairs could be nested. Match
 682         // only leaf pairs with supported parameters.
 683         size_t next_template_start = parsed_url.find(kStartParameter, last + 1);
 684         if (next_template_start == std::string::npos ||
 685             next_template_start > template_end) {
 686           // If successful, ParseParameter erases from the string as such no
 687           // need to update |last|. If failed, move |last| to the end of pair.
 688           if (!ParseParameter(last, template_end, &parsed_url, replacements)) {
 689             // |template_end| + 1 may be beyond the end of the string.
 690             last = template_end;
 691           }
 692         } else {
 693           last = next_template_start;
 694         }
 695       } else {
 696         // Open brace without a closing brace, return.
 697         return std::string();
 698       }
 699     }
 700   }
 701
 702   // Handles the post parameters.
 703   const std::string& post_params_string = GetPostParamsString();
 704   if (!post_params_string.empty()) {
 705     typedef std::vector<std::string> Strings;
 706     Strings param_list;
 707     base::SplitString(post_params_string, ',', &param_list);
 708
 709     for (Strings::const_iterator iterator = param_list.begin();
 710          iterator != param_list.end(); ++iterator) {
 711       Strings parts;
 712       // The '=' delimiter is required and the name must be not empty.
 713       base::SplitString(*iterator, '=', &parts);
 714       if ((parts.size() != 2U) || parts[0].empty())
 715         return std::string();
 716
 717       std::string& value = parts[1];
 718       size_t replacements_size = replacements->size();
 719       if (IsTemplateParameterString(value))
 720         ParseParameter(0, value.length() - 1, &value, replacements);
 721       post_params->push_back(std::make_pair(parts[0], value));
 722       // If there was a replacement added, points its index to last added
 723       // PostParam.
 724       if (replacements->size() > replacements_size) {
 725         DCHECK_EQ(replacements_size + 1, replacements->size());
 726         Replacement* r = &replacements->back();
 727         r->is_post_param = true;
 728         r->index = post_params->size() - 1;
 729       }
 730     }
 731     DCHECK(!post_params->empty());
 732   }
 733
 734   *valid = true;
 735   return parsed_url;
 736 }
 737
 738 void TemplateURLRef::ParseIfNecessary(
 739     const SearchTermsData& search_terms_data) const {
 740   if (!parsed_) {
 741     InvalidateCachedValues();
 742     parsed_ = true;
 743     parsed_url_ = ParseURL(GetURL(), &replacements_, &post_params_, &valid_);
 744     supports_replacements_ = false;
 745     if (valid_) {
 746       bool has_only_one_search_term = false;
 747       for (Replacements::const_iterator i = replacements_.begin();
 748            i != replacements_.end(); ++i) {
 749         if ((i->type == SEARCH_TERMS) ||
 750             (i->type == GOOGLE_UNESCAPED_SEARCH_TERMS)) {
 751           if (has_only_one_search_term) {
 752             has_only_one_search_term = false;
 753             break;
 754           }
 755           has_only_one_search_term = true;
 756           supports_replacements_ = true;
 757         }
 758       }
 759       // Only parse the host/key if there is one search term. Technically there
 760       // could be more than one term, but it's uncommon; so we punt.
 761       if (has_only_one_search_term)
 762         ParseHostAndSearchTermKey(search_terms_data);
 763     }
 764   }
 765 }
 766
 767 void TemplateURLRef::ParseHostAndSearchTermKey(
 768     const SearchTermsData& search_terms_data) const {
 769   std::string url_string(GetURL());
 770   ReplaceSubstringsAfterOffset(&url_string, 0,
 771                                kGoogleBaseURLParameterFull,
 772                                search_terms_data.GoogleBaseURLValue());
 773   ReplaceSubstringsAfterOffset(&url_string, 0,
 774                                kGoogleBaseSuggestURLParameterFull,
 775                                search_terms_data.GoogleBaseSuggestURLValue());
 776
 777   search_term_key_.clear();
 778   host_.clear();
 779   path_.clear();
 780   search_term_key_location_ = url::Parsed::REF;
 781
 782   GURL url(url_string);
 783   if (!url.is_valid())
 784     return;
 785
 786   std::string query_key = FindSearchTermsKey(url.query());
 787   std::string ref_key = FindSearchTermsKey(url.ref());
 788   if (query_key.empty() == ref_key.empty())
 789     return;  // No key or multiple keys found.  We only handle having one key.
 790   search_term_key_ = query_key.empty() ? ref_key : query_key;
 791   search_term_key_location_ =
 792       query_key.empty() ? url::Parsed::REF : url::Parsed::QUERY;
 793   host_ = url.host();
 794   path_ = url.path();
 795 }
 796
 797 void TemplateURLRef::HandleReplacement(const std::string& name,
 798                                        const std::string& value,
 799                                        const Replacement& replacement,
 800                                        std::string* url) const {
 801   size_t pos = replacement.index;
 802   if (replacement.is_post_param) {
 803     DCHECK_LT(pos, post_params_.size());
 804     DCHECK(!post_params_[pos].first.empty());
 805     post_params_[pos].second = value;
 806   } else {
 807     url->insert(pos, name.empty() ? value : (name + "=" + value + "&"));
 808   }
 809 }
 810
 811 std::string TemplateURLRef::HandleReplacements(
 812     const SearchTermsArgs& search_terms_args,
 813     const SearchTermsData& search_terms_data,
 814     PostContent* post_content) const {
 815   if (replacements_.empty()) {
 816     if (!post_params_.empty())
 817       EncodeFormData(post_params_, post_content);
 818     return parsed_url_;
 819   }
 820
 821   // Determine if the search terms are in the query or before. We're escaping
 822   // space as '+' in the former case and as '%20' in the latter case.
 823   bool is_in_query = true;
 824   for (Replacements::iterator i = replacements_.begin();
 825        i != replacements_.end(); ++i) {
 826     if (i->type == SEARCH_TERMS) {
 827       base::string16::size_type query_start = parsed_url_.find('?');
 828       is_in_query = query_start != base::string16::npos &&
 829           (static_cast<base::string16::size_type>(i->index) > query_start);
 830       break;
 831     }
 832   }
 833
 834   std::string input_encoding;
 835   base::string16 encoded_terms;
 836   base::string16 encoded_original_query;
 837   owner_->EncodeSearchTerms(search_terms_args, is_in_query, &input_encoding,
 838                             &encoded_terms, &encoded_original_query);
 839
 840   std::string url = parsed_url_;
 841
 842   // replacements_ is ordered in ascending order, as such we need to iterate
 843   // from the back.
 844   for (Replacements::reverse_iterator i = replacements_.rbegin();
 845        i != replacements_.rend(); ++i) {
 846     switch (i->type) {
 847       case ENCODING:
 848         HandleReplacement(std::string(), input_encoding, *i, &url);
 849         break;
 850
 851       case GOOGLE_ASSISTED_QUERY_STATS:
 852         DCHECK(!i->is_post_param);
 853         if (!search_terms_args.assisted_query_stats.empty()) {
 854           // Get the base URL without substituting AQS to avoid infinite
 855           // recursion.  We need the URL to find out if it meets all
 856           // AQS requirements (e.g. HTTPS protocol check).
 857           // See TemplateURLRef::SearchTermsArgs for more details.
 858           SearchTermsArgs search_terms_args_without_aqs(search_terms_args);
 859           search_terms_args_without_aqs.assisted_query_stats.clear();
 860           GURL base_url(ReplaceSearchTerms(
 861               search_terms_args_without_aqs, search_terms_data, NULL));
 862           if (base_url.SchemeIs(url::kHttpsScheme)) {
 863             HandleReplacement(
 864                 "aqs", search_terms_args.assisted_query_stats, *i, &url);
 865           }
 866         }
 867         break;
 868
 869       case GOOGLE_BASE_URL:
 870         DCHECK(!i->is_post_param);
 871         HandleReplacement(
 872             std::string(), search_terms_data.GoogleBaseURLValue(), *i, &url);
 873         break;
 874
 875       case GOOGLE_BASE_SUGGEST_URL:
 876         DCHECK(!i->is_post_param);
 877         HandleReplacement(
 878             std::string(), search_terms_data.GoogleBaseSuggestURLValue(), *i,
 879             &url);
 880         break;
 881
 882       case GOOGLE_BOOKMARK_BAR_PINNED:
 883         if (search_terms_data.IsShowingSearchTermsOnSearchResultsPages()) {
 884           // Log whether the bookmark bar is pinned when the user is seeing
 885           // InstantExtended on the SRP.
 886           DCHECK(!i->is_post_param);
 887           HandleReplacement(
 888               "bmbp", search_terms_args.bookmark_bar_pinned ? "1" : "0", *i,
 889               &url);
 890         }
 891         break;
 892
 893       case GOOGLE_CURRENT_PAGE_URL:
 894         DCHECK(!i->is_post_param);
 895         if (!search_terms_args.current_page_url.empty()) {
 896           const std::string& escaped_current_page_url =
 897               net::EscapeQueryParamValue(search_terms_args.current_page_url,
 898                                          true);
 899           HandleReplacement("url", escaped_current_page_url, *i, &url);
 900         }
 901         break;
 902
 903       case GOOGLE_CURSOR_POSITION:
 904         DCHECK(!i->is_post_param);
 905         if (search_terms_args.cursor_position != base::string16::npos)
 906           HandleReplacement(
 907               "cp",
 908               base::StringPrintf("%" PRIuS, search_terms_args.cursor_position),
 909               *i,
 910               &url);
 911         break;
 912
 913       case GOOGLE_FORCE_INSTANT_RESULTS:
 914         DCHECK(!i->is_post_param);
 915         HandleReplacement(std::string(),
 916                           search_terms_data.ForceInstantResultsParam(
 917                               search_terms_args.force_instant_results),
 918                           *i,
 919                           &url);
 920         break;
 921
 922       case GOOGLE_INPUT_TYPE:
 923         DCHECK(!i->is_post_param);
 924         HandleReplacement(
 925             "oit", base::IntToString(search_terms_args.input_type), *i, &url);
 926         break;
 927
 928       case GOOGLE_INSTANT_EXTENDED_ENABLED:
 929         DCHECK(!i->is_post_param);
 930         HandleReplacement(std::string(),
 931                           search_terms_data.InstantExtendedEnabledParam(
 932                               type_ == SEARCH),
 933                           *i,
 934                           &url);
 935         break;
 936
 937       case GOOGLE_NTP_IS_THEMED:
 938         DCHECK(!i->is_post_param);
 939         HandleReplacement(
 940             std::string(), search_terms_data.NTPIsThemedParam(), *i, &url);
 941         break;
 942
 943       case GOOGLE_OMNIBOX_START_MARGIN:
 944         DCHECK(!i->is_post_param);
 945         if (search_terms_args.enable_omnibox_start_margin) {
 946           int omnibox_start_margin = search_terms_data.OmniboxStartMargin();
 947           if (omnibox_start_margin >= 0) {
 948             HandleReplacement("es_sm", base::IntToString(omnibox_start_margin),
 949                               *i, &url);
 950           }
 951         }
 952         break;
 953
 954       case GOOGLE_CONTEXTUAL_SEARCH_VERSION:
 955         if (search_terms_args.contextual_search_params.version >= 0) {
 956           HandleReplacement(
 957               "ctxs",
 958               base::IntToString(
 959                   search_terms_args.contextual_search_params.version),
 960               *i,
 961               &url);
 962         }
 963         break;
 964
 965       case GOOGLE_CONTEXTUAL_SEARCH_CONTEXT_DATA: {
 966         DCHECK(!i->is_post_param);
 967         std::string context_data;
 968
 969         const SearchTermsArgs::ContextualSearchParams& params =
 970             search_terms_args.contextual_search_params;
 971
 972         if (params.start != std::string::npos) {
 973           context_data.append("ctxs_start=" + base::IntToString(
 974               params.start) + "&");
 975         }
 976
 977         if (params.end != std::string::npos) {
 978           context_data.append("ctxs_end=" + base::IntToString(
 979               params.end) + "&");
 980         }
 981
 982         if (!params.selection.empty())
 983           context_data.append("q=" + params.selection + "&");
 984
 985         if (!params.content.empty())
 986           context_data.append("ctxs_content=" + params.content + "&");
 987
 988         if (!params.base_page_url.empty())
 989           context_data.append("ctxsl_url=" + params.base_page_url + "&");
 990
 991         if (!params.encoding.empty()) {
 992           context_data.append("ctxs_encoding=" + params.encoding + "&");
 993         }
 994
 995         context_data.append(
 996             params.resolve ? "ctxsl_resolve=1" : "ctxsl_resolve=0");
 997
 998         HandleReplacement(std::string(), context_data, *i, &url);
 999         break;
1000       }
1001
1002       case GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION:
1003         DCHECK(!i->is_post_param);
1004         if (search_terms_args.accepted_suggestion >= 0 ||
1005             !search_terms_args.assisted_query_stats.empty()) {
1006           HandleReplacement(
1007               "oq", base::UTF16ToUTF8(encoded_original_query), *i, &url);
1008         }
1009         break;
1010
1011       case GOOGLE_PAGE_CLASSIFICATION:
1012         if (search_terms_args.page_classification !=
1013             metrics::OmniboxEventProto::INVALID_SPEC) {
1014           HandleReplacement(
1015               "pgcl", base::IntToString(search_terms_args.page_classification),
1016               *i, &url);
1017         }
1018         break;
1019
1020       case GOOGLE_PREFETCH_QUERY: {
1021         const std::string& query = search_terms_args.prefetch_query;
1022         const std::string& type = search_terms_args.prefetch_query_type;
1023         if (!query.empty() && !type.empty()) {
1024           HandleReplacement(
1025               std::string(), "pfq=" + query + "&qha=" + type + "&", *i, &url);
1026         }
1027         break;
1028       }
1029
1030       case GOOGLE_RLZ: {
1031         DCHECK(!i->is_post_param);
1032         // On platforms that don't have RLZ, we still want this branch
1033         // to happen so that we replace the RLZ template with the
1034         // empty string.  (If we don't handle this case, we hit a
1035         // NOTREACHED below.)
1036         base::string16 rlz_string = search_terms_data.GetRlzParameterValue(
1037             search_terms_args.from_app_list);
1038         if (!rlz_string.empty()) {
1039           HandleReplacement("rlz", base::UTF16ToUTF8(rlz_string), *i, &url);
1040         }
1041         break;
1042       }
1043
1044       case GOOGLE_SEARCH_CLIENT: {
1045         DCHECK(!i->is_post_param);
1046         std::string client = search_terms_data.GetSearchClient();
1047         if (!client.empty())
1048           HandleReplacement("client", client, *i, &url);
1049         break;
1050       }
1051
1052       case GOOGLE_SEARCH_FIELDTRIAL_GROUP:
1053         // We are not currently running any fieldtrials that modulate the search
1054         // url.  If we do, then we'd have some conditional insert such as:
1055         // url.insert(i->index, used_www ? "gcx=w&" : "gcx=c&");
1056         break;
1057
1058       case GOOGLE_SEARCH_VERSION:
1059         if (search_terms_data.EnableAnswersInSuggest())
1060           HandleReplacement("gs_rn", "42", *i, &url);
1061         break;
1062
1063       case GOOGLE_SESSION_TOKEN: {
1064         std::string token = search_terms_args.session_token;
1065         if (!token.empty())
1066           HandleReplacement("psi", token, *i, &url);
1067         break;
1068       }
1069
1070       case GOOGLE_SUGGEST_CLIENT:
1071         HandleReplacement(
1072             std::string(), search_terms_data.GetSuggestClient(), *i, &url);
1073         break;
1074
1075       case GOOGLE_SUGGEST_REQUEST_ID:
1076         HandleReplacement(
1077             std::string(), search_terms_data.GetSuggestRequestIdentifier(), *i,
1078             &url);
1079         break;
1080
1081       case GOOGLE_UNESCAPED_SEARCH_TERMS: {
1082         std::string unescaped_terms;
1083         base::UTF16ToCodepage(search_terms_args.search_terms,
1084                               input_encoding.c_str(),
1085                               base::OnStringConversionError::SKIP,
1086                               &unescaped_terms);
1087         HandleReplacement(std::string(), unescaped_terms, *i, &url);
1088         break;
1089       }
1090
1091       case LANGUAGE:
1092         HandleReplacement(
1093             std::string(), search_terms_data.GetApplicationLocale(), *i, &url);
1094         break;
1095
1096       case SEARCH_TERMS:
1097         HandleReplacement(
1098             std::string(), base::UTF16ToUTF8(encoded_terms), *i, &url);
1099         break;
1100
1101       case GOOGLE_IMAGE_THUMBNAIL:
1102         HandleReplacement(
1103             std::string(), search_terms_args.image_thumbnail_content, *i, &url);
1104         break;
1105
1106       case GOOGLE_IMAGE_URL:
1107         if (search_terms_args.image_url.is_valid()) {
1108           HandleReplacement(
1109               std::string(), search_terms_args.image_url.spec(), *i, &url);
1110         }
1111         break;
1112
1113       case GOOGLE_IMAGE_ORIGINAL_WIDTH:
1114         if (!search_terms_args.image_original_size.IsEmpty()) {
1115           HandleReplacement(
1116               std::string(),
1117               base::IntToString(search_terms_args.image_original_size.width()),
1118               *i, &url);
1119         }
1120         break;
1121
1122       case GOOGLE_IMAGE_ORIGINAL_HEIGHT:
1123         if (!search_terms_args.image_original_size.IsEmpty()) {
1124           HandleReplacement(
1125               std::string(),
1126               base::IntToString(search_terms_args.image_original_size.height()),
1127               *i, &url);
1128         }
1129         break;
1130
1131       case GOOGLE_IMAGE_SEARCH_SOURCE:
1132         HandleReplacement(
1133             std::string(), search_terms_data.GoogleImageSearchSource(), *i,
1134             &url);
1135         break;
1136
1137       default:
1138         NOTREACHED();
1139         break;
1140     }
1141   }
1142
1143   if (!post_params_.empty())
1144     EncodeFormData(post_params_, post_content);
1145
1146   return url;
1147 }
1148
1149
1150 // TemplateURL ----------------------------------------------------------------
1151
1152 TemplateURL::AssociatedExtensionInfo::AssociatedExtensionInfo(
1153     Type type,
1154     const std::string& extension_id)
1155     : type(type),
1156       extension_id(extension_id),
1157       wants_to_be_default_engine(false) {
1158   DCHECK_NE(NORMAL, type);
1159 }
1160
1161 TemplateURL::AssociatedExtensionInfo::~AssociatedExtensionInfo() {
1162 }
1163
1164 TemplateURL::TemplateURL(const TemplateURLData& data)
1165     : data_(data),
1166       url_ref_(this, TemplateURLRef::SEARCH),
1167       suggestions_url_ref_(this,
1168                            TemplateURLRef::SUGGEST),
1169       instant_url_ref_(this,
1170                        TemplateURLRef::INSTANT),
1171       image_url_ref_(this, TemplateURLRef::IMAGE),
1172       new_tab_url_ref_(this, TemplateURLRef::NEW_TAB),
1173       contextual_search_url_ref_(this, TemplateURLRef::CONTEXTUAL_SEARCH) {
1174   SetPrepopulateId(data_.prepopulate_id);
1175
1176   if (data_.search_terms_replacement_key ==
1177       kGoogleInstantExtendedEnabledKeyFull) {
1178     data_.search_terms_replacement_key = google_util::kInstantExtendedAPIParam;
1179   }
1180 }
1181
1182 TemplateURL::~TemplateURL() {
1183 }
1184
1185 // static
1186 base::string16 TemplateURL::GenerateKeyword(const GURL& url) {
1187   DCHECK(url.is_valid());
1188   // Strip "www." off the front of the keyword; otherwise the keyword won't work
1189   // properly.  See http://code.google.com/p/chromium/issues/detail?id=6984 .
1190   // Special case: if the host was exactly "www." (not sure this can happen but
1191   // perhaps with some weird intranet and custom DNS server?), ensure we at
1192   // least don't return the empty string.
1193   base::string16 keyword(net::StripWWWFromHost(url));
1194   return keyword.empty() ? base::ASCIIToUTF16("www") : keyword;
1195 }
1196
1197 // static
1198 GURL TemplateURL::GenerateFaviconURL(const GURL& url) {
1199   DCHECK(url.is_valid());
1200   GURL::Replacements rep;
1201
1202   const char favicon_path[] = "/favicon.ico";
1203   int favicon_path_len = arraysize(favicon_path) - 1;
1204
1205   rep.SetPath(favicon_path, url::Component(0, favicon_path_len));
1206   rep.ClearUsername();
1207   rep.ClearPassword();
1208   rep.ClearQuery();
1209   rep.ClearRef();
1210   return url.ReplaceComponents(rep);
1211 }
1212
1213 // static
1214 bool TemplateURL::MatchesData(const TemplateURL* t_url,
1215                               const TemplateURLData* data,
1216                               const SearchTermsData& search_terms_data) {
1217   if (!t_url || !data)
1218     return !t_url && !data;
1219
1220   return (t_url->short_name() == data->short_name) &&
1221       t_url->HasSameKeywordAs(*data, search_terms_data) &&
1222       (t_url->url() == data->url()) &&
1223       (t_url->suggestions_url() == data->suggestions_url) &&
1224       (t_url->instant_url() == data->instant_url) &&
1225       (t_url->image_url() == data->image_url) &&
1226       (t_url->new_tab_url() == data->new_tab_url) &&
1227       (t_url->search_url_post_params() == data->search_url_post_params) &&
1228       (t_url->suggestions_url_post_params() ==
1229           data->suggestions_url_post_params) &&
1230       (t_url->instant_url_post_params() == data->instant_url_post_params) &&
1231       (t_url->image_url_post_params() == data->image_url_post_params) &&
1232       (t_url->favicon_url() == data->favicon_url) &&
1233       (t_url->safe_for_autoreplace() == data->safe_for_autoreplace) &&
1234       (t_url->show_in_default_list() == data->show_in_default_list) &&
1235       (t_url->input_encodings() == data->input_encodings) &&
1236       (t_url->alternate_urls() == data->alternate_urls) &&
1237       (t_url->search_terms_replacement_key() ==
1238           data->search_terms_replacement_key);
1239 }
1240
1241 base::string16 TemplateURL::AdjustedShortNameForLocaleDirection() const {
1242   base::string16 bidi_safe_short_name = data_.short_name;
1243   base::i18n::AdjustStringForLocaleDirection(&bidi_safe_short_name);
1244   return bidi_safe_short_name;
1245 }
1246
1247 bool TemplateURL::ShowInDefaultList(
1248     const SearchTermsData& search_terms_data) const {
1249   return data_.show_in_default_list &&
1250       url_ref_.SupportsReplacement(search_terms_data);
1251 }
1252
1253 bool TemplateURL::SupportsReplacement(
1254     const SearchTermsData& search_terms_data) const {
1255   return url_ref_.SupportsReplacement(search_terms_data);
1256 }
1257
1258 bool TemplateURL::HasGoogleBaseURLs(
1259     const SearchTermsData& search_terms_data) const {
1260   return url_ref_.HasGoogleBaseURLs(search_terms_data) ||
1261       suggestions_url_ref_.HasGoogleBaseURLs(search_terms_data) ||
1262       instant_url_ref_.HasGoogleBaseURLs(search_terms_data) ||
1263       image_url_ref_.HasGoogleBaseURLs(search_terms_data) ||
1264       new_tab_url_ref_.HasGoogleBaseURLs(search_terms_data);
1265 }
1266
1267 bool TemplateURL::IsGoogleSearchURLWithReplaceableKeyword(
1268     const SearchTermsData& search_terms_data) const {
1269   return (GetType() == NORMAL) &&
1270       url_ref_.HasGoogleBaseURLs(search_terms_data) &&
1271       google_util::IsGoogleHostname(base::UTF16ToUTF8(data_.keyword()),
1272                                     google_util::DISALLOW_SUBDOMAIN);
1273 }
1274
1275 bool TemplateURL::HasSameKeywordAs(
1276     const TemplateURLData& other,
1277     const SearchTermsData& search_terms_data) const {
1278   return (data_.keyword() == other.keyword()) ||
1279       (IsGoogleSearchURLWithReplaceableKeyword(search_terms_data) &&
1280        TemplateURL(other).IsGoogleSearchURLWithReplaceableKeyword(
1281            search_terms_data));
1282 }
1283
1284 TemplateURL::Type TemplateURL::GetType() const {
1285   return extension_info_ ? extension_info_->type : NORMAL;
1286 }
1287
1288 std::string TemplateURL::GetExtensionId() const {
1289   DCHECK(extension_info_);
1290   return extension_info_->extension_id;
1291 }
1292
1293 size_t TemplateURL::URLCount() const {
1294   // Add 1 for the regular search URL.
1295   return data_.alternate_urls.size() + 1;
1296 }
1297
1298 const std::string& TemplateURL::GetURL(size_t index) const {
1299   DCHECK_LT(index, URLCount());
1300
1301   return (index < data_.alternate_urls.size()) ?
1302       data_.alternate_urls[index] : url();
1303 }
1304
1305 bool TemplateURL::ExtractSearchTermsFromURL(
1306     const GURL& url,
1307     const SearchTermsData& search_terms_data,
1308     base::string16* search_terms) {
1309   return FindSearchTermsInURL(url, search_terms_data, search_terms, NULL, NULL);
1310 }
1311
1312 bool TemplateURL::IsSearchURL(
1313     const GURL& url,
1314     const SearchTermsData& search_terms_data) {
1315   base::string16 search_terms;
1316   return ExtractSearchTermsFromURL(url, search_terms_data, &search_terms) &&
1317       !search_terms.empty();
1318 }
1319
1320 bool TemplateURL::HasSearchTermsReplacementKey(const GURL& url) const {
1321   // Look for the key both in the query and the ref.
1322   std::string params[] = {url.query(), url.ref()};
1323
1324   for (int i = 0; i < 2; ++i) {
1325     url::Component query, key, value;
1326     query.len = static_cast<int>(params[i].size());
1327     while (url::ExtractQueryKeyValue(params[i].c_str(), &query, &key, &value)) {
1328       if (key.is_nonempty() &&
1329           params[i].substr(key.begin, key.len) ==
1330               search_terms_replacement_key()) {
1331         return true;
1332       }
1333     }
1334   }
1335   return false;
1336 }
1337
1338 bool TemplateURL::ReplaceSearchTermsInURL(
1339     const GURL& url,
1340     const TemplateURLRef::SearchTermsArgs& search_terms_args,
1341     const SearchTermsData& search_terms_data,
1342     GURL* result) {
1343   // TODO(beaudoin): Use AQS from |search_terms_args| too.
1344   url::Parsed::ComponentType search_term_component;
1345   url::Component search_terms_position;
1346   base::string16 search_terms;
1347   if (!FindSearchTermsInURL(url, search_terms_data, &search_terms,
1348                             &search_term_component, &search_terms_position)) {
1349     return false;
1350   }
1351   DCHECK(search_terms_position.is_nonempty());
1352
1353   // FindSearchTermsInURL only returns true for search terms in the query or
1354   // ref, so we can call EncodeSearchTerm with |is_in_query| = true, since query
1355   // and ref are encoded in the same way.
1356   std::string input_encoding;
1357   base::string16 encoded_terms;
1358   base::string16 encoded_original_query;
1359   EncodeSearchTerms(search_terms_args, true, &input_encoding,
1360                     &encoded_terms, &encoded_original_query);
1361
1362   std::string old_params(
1363       (search_term_component == url::Parsed::REF) ? url.ref() : url.query());
1364   std::string new_params(old_params, 0, search_terms_position.begin);
1365   new_params += base::UTF16ToUTF8(search_terms_args.search_terms);
1366   new_params += old_params.substr(search_terms_position.end());
1367   url::StdStringReplacements<std::string> replacements;
1368   if (search_term_component == url::Parsed::REF)
1369     replacements.SetRefStr(new_params);
1370   else
1371     replacements.SetQueryStr(new_params);
1372   *result = url.ReplaceComponents(replacements);
1373   return true;
1374 }
1375
1376 void TemplateURL::EncodeSearchTerms(
1377     const TemplateURLRef::SearchTermsArgs& search_terms_args,
1378     bool is_in_query,
1379     std::string* input_encoding,
1380     base::string16* encoded_terms,
1381     base::string16* encoded_original_query) const {
1382
1383   std::vector<std::string> encodings(input_encodings());
1384   if (std::find(encodings.begin(), encodings.end(), "UTF-8") == encodings.end())
1385     encodings.push_back("UTF-8");
1386   for (std::vector<std::string>::const_iterator i(encodings.begin());
1387        i != encodings.end(); ++i) {
1388     if (TryEncoding(search_terms_args.search_terms,
1389                     search_terms_args.original_query, i->c_str(),
1390                     is_in_query, encoded_terms, encoded_original_query)) {
1391       *input_encoding = *i;
1392       return;
1393     }
1394   }
1395   NOTREACHED();
1396 }
1397
1398 GURL TemplateURL::GenerateSearchURL(
1399     const SearchTermsData& search_terms_data) const {
1400   if (!url_ref_.IsValid(search_terms_data))
1401     return GURL();
1402
1403   if (!url_ref_.SupportsReplacement(search_terms_data))
1404     return GURL(url());
1405
1406   // Use something obscure for the search terms argument so that in the rare
1407   // case the term replaces the URL it's unlikely another keyword would have the
1408   // same url.
1409   // TODO(jnd): Add additional parameters to get post data when the search URL
1410   // has post parameters.
1411   return GURL(url_ref_.ReplaceSearchTerms(
1412       TemplateURLRef::SearchTermsArgs(
1413           base::ASCIIToUTF16("blah.blah.blah.blah.blah")),
1414       search_terms_data, NULL));
1415 }
1416
1417 void TemplateURL::CopyFrom(const TemplateURL& other) {
1418   if (this == &other)
1419     return;
1420
1421   data_ = other.data_;
1422   url_ref_.InvalidateCachedValues();
1423   suggestions_url_ref_.InvalidateCachedValues();
1424   instant_url_ref_.InvalidateCachedValues();
1425   SetPrepopulateId(other.data_.prepopulate_id);
1426 }
1427
1428 void TemplateURL::SetURL(const std::string& url) {
1429   data_.SetURL(url);
1430   url_ref_.InvalidateCachedValues();
1431 }
1432
1433 void TemplateURL::SetPrepopulateId(int id) {
1434   data_.prepopulate_id = id;
1435   const bool prepopulated = id > 0;
1436   url_ref_.prepopulated_ = prepopulated;
1437   suggestions_url_ref_.prepopulated_ = prepopulated;
1438   instant_url_ref_.prepopulated_ = prepopulated;
1439 }
1440
1441 void TemplateURL::ResetKeywordIfNecessary(
1442     const SearchTermsData& search_terms_data,
1443     bool force) {
1444   if (IsGoogleSearchURLWithReplaceableKeyword(search_terms_data) || force) {
1445     DCHECK(GetType() != OMNIBOX_API_EXTENSION);
1446     GURL url(GenerateSearchURL(search_terms_data));
1447     if (url.is_valid())
1448       data_.SetKeyword(GenerateKeyword(url));
1449   }
1450 }
1451
1452 bool TemplateURL::FindSearchTermsInURL(
1453     const GURL& url,
1454     const SearchTermsData& search_terms_data,
1455     base::string16* search_terms,
1456     url::Parsed::ComponentType* search_term_component,
1457     url::Component* search_terms_position) {
1458   DCHECK(search_terms);
1459   search_terms->clear();
1460
1461   // Try to match with every pattern.
1462   for (size_t i = 0; i < URLCount(); ++i) {
1463     TemplateURLRef ref(this, i);
1464     if (ref.ExtractSearchTermsFromURL(url, search_terms, search_terms_data,
1465         search_term_component, search_terms_position)) {
1466       // If ExtractSearchTermsFromURL() returns true and |search_terms| is empty
1467       // it means the pattern matched but no search terms were present. In this
1468       // case we fail immediately without looking for matches in subsequent
1469       // patterns. This means that given patterns
1470       //    [ "http://foo/#q={searchTerms}", "http://foo/?q={searchTerms}" ],
1471       // calling ExtractSearchTermsFromURL() on "http://foo/?q=bar#q=' would
1472       // return false. This is important for at least Google, where such URLs
1473       // are invalid.
1474       return !search_terms->empty();
1475     }
1476   }
1477   return false;
1478 }