123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818 |
- // Copyright 2014 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 "components/search_engines/template_url.h"
- #include <string>
- #include <tuple>
- #include <vector>
- #include "base/base64.h"
- #include "base/base64url.h"
- #include "base/check_op.h"
- #include "base/command_line.h"
- #include "base/containers/adapters.h"
- #include "base/containers/contains.h"
- #include "base/feature_list.h"
- #include "base/format_macros.h"
- #include "base/i18n/case_conversion.h"
- #include "base/i18n/icu_string_conversions.h"
- #include "base/i18n/rtl.h"
- #include "base/metrics/field_trial.h"
- #include "base/metrics/histogram_functions.h"
- #include "base/notreached.h"
- #include "base/strings/escape.h"
- #include "base/strings/string_number_conversions.h"
- #include "base/strings/string_piece.h"
- #include "base/strings/string_split.h"
- #include "base/strings/string_util.h"
- #include "base/strings/stringprintf.h"
- #include "base/strings/utf_string_conversions.h"
- #include "base/trace_event/memory_usage_estimator.h"
- #include "build/build_config.h"
- #include "components/google/core/common/google_util.h"
- #include "components/omnibox/common/omnibox_features.h"
- #include "components/search_engines/search_engine_utils.h"
- #include "components/search_engines/search_engines_switches.h"
- #include "components/search_engines/search_terms_data.h"
- #include "components/url_formatter/url_formatter.h"
- #include "google_apis/google_api_keys.h"
- #include "net/base/mime_util.h"
- #include "net/base/url_util.h"
- #include "template_url_starter_pack_data.h"
- #include "third_party/metrics_proto/omnibox_input_type.pb.h"
- #include "ui/base/device_form_factor.h"
- #include "url/gurl.h"
- namespace {
- // The TemplateURLRef has any number of terms that need to be replaced. Each of
- // the terms is enclosed in braces. If the character preceeding the final
- // brace is a ?, it indicates the term is optional and can be replaced with
- // an empty string.
- const char kStartParameter = '{';
- const char kEndParameter = '}';
- const char kOptional = '?';
- // Known parameters found in the URL.
- const char kSearchTermsParameter[] = "searchTerms";
- const char kSearchTermsParameterFull[] = "{searchTerms}";
- const char kSearchTermsParameterFullEscaped[] = "%7BsearchTerms%7D";
- // Same as kSearchTermsParameter, with no escaping.
- const char kGoogleUnescapedSearchTermsParameter[] =
- "google:unescapedSearchTerms";
- const char kGoogleUnescapedSearchTermsParameterFull[] =
- "{google:unescapedSearchTerms}";
- // Display value for kSearchTermsParameter.
- const char kDisplaySearchTerms[] = "%s";
- // Display value for kGoogleUnescapedSearchTermsParameter.
- const char kDisplayUnescapedSearchTerms[] = "%S";
- // Used if the count parameter is not optional. Indicates we want 10 search
- // results.
- const char kDefaultCount[] = "10";
- // Used if the output encoding parameter is required.
- const char kOutputEncodingType[] = "UTF-8";
- const size_t kMaxStringEncodeStringLength = 1'000'000;
- // Attempts to encode |terms| and |original_query| in |encoding| and escape
- // them. |terms| may be escaped as path or query depending on |is_in_query|;
- // |original_query| is always escaped as query. If |force_encode| is true
- // encoding ignores errors and function always returns true. Otherwise function
- // returns whether the encoding process succeeded.
- bool TryEncoding(const std::u16string& terms,
- const std::u16string& original_query,
- const char* encoding,
- bool is_in_query,
- bool force_encode,
- std::u16string* escaped_terms,
- std::u16string* escaped_original_query) {
- DCHECK(escaped_terms);
- DCHECK(escaped_original_query);
- // Both |base::UTF16ToCodepage()| and |net::Escape*()| invocations below
- // create strings longer than their inputs. To ensure doing so does not crash,
- // this truncates |terms| to |kMaxStringEncodeStringLength|.
- const std::u16string& truncated_terms =
- terms.size() > kMaxStringEncodeStringLength
- ? terms.substr(0, kMaxStringEncodeStringLength)
- : terms;
- base::OnStringConversionError::Type error_handling =
- force_encode ? base::OnStringConversionError::SKIP
- : base::OnStringConversionError::FAIL;
- std::string encoded_terms;
- if (!base::UTF16ToCodepage(truncated_terms, encoding, error_handling,
- &encoded_terms)) {
- return false;
- }
- *escaped_terms = base::UTF8ToUTF16(
- is_in_query ? base::EscapeQueryParamValue(encoded_terms, true)
- : base::EscapePath(encoded_terms));
- if (original_query.empty())
- return true;
- std::string encoded_original_query;
- if (!base::UTF16ToCodepage(original_query, encoding, error_handling,
- &encoded_original_query))
- return false;
- *escaped_original_query = base::UTF8ToUTF16(
- base::EscapeQueryParamValue(encoded_original_query, true));
- return true;
- }
- // Finds the position of the search terms' parameter in the URL component.
- class SearchTermLocation {
- public:
- SearchTermLocation(const base::StringPiece& url_component,
- url::Parsed::ComponentType url_component_type)
- : found_(false) {
- if (url_component_type == url::Parsed::PATH) {
- // GURL's constructor escapes "{" and "}" in the path of a passed string.
- found_ =
- TryMatchSearchParam(url_component, kSearchTermsParameterFullEscaped);
- } else {
- DCHECK((url_component_type == url::Parsed::QUERY) ||
- (url_component_type == url::Parsed::REF));
- url::Component query, key, value;
- query.len = static_cast<int>(url_component.size());
- while (url::ExtractQueryKeyValue(url_component.data(), &query, &key,
- &value)) {
- if (key.is_nonempty() && value.is_nonempty()) {
- const base::StringPiece value_string =
- url_component.substr(value.begin, value.len);
- if (TryMatchSearchParam(value_string, kSearchTermsParameterFull) ||
- TryMatchSearchParam(value_string,
- kGoogleUnescapedSearchTermsParameterFull)) {
- found_ = true;
- key_ = std::string(url_component.substr(key.begin, key.len));
- break;
- }
- }
- }
- }
- }
- SearchTermLocation(const SearchTermLocation&) = delete;
- SearchTermLocation& operator=(const SearchTermLocation&) = delete;
- bool found() const { return found_; }
- const std::string& key() const { return key_; }
- const std::string& value_prefix() const { return value_prefix_; }
- const std::string& value_suffix() const { return value_suffix_; }
- private:
- // Returns true if the search term placeholder is present, and also assigns
- // the constant prefix/suffix found.
- bool TryMatchSearchParam(const base::StringPiece& value,
- const base::StringPiece& pattern) {
- size_t pos = value.find(pattern);
- if (pos == base::StringPiece::npos)
- return false;
- value_prefix_ = std::string(value.substr(0, pos));
- value_suffix_ = std::string(value.substr(pos + pattern.size()));
- return true;
- }
- bool found_;
- std::string key_;
- std::string value_prefix_;
- std::string value_suffix_;
- };
- bool IsTemplateParameterString(const std::string& param) {
- return (param.length() > 2) && (*(param.begin()) == kStartParameter) &&
- (*(param.rbegin()) == kEndParameter);
- }
- std::string YandexSearchPathFromDeviceFormFactor() {
- switch (ui::GetDeviceFormFactor()) {
- case ui::DEVICE_FORM_FACTOR_DESKTOP:
- return "search/";
- case ui::DEVICE_FORM_FACTOR_PHONE:
- return "search/touch/";
- case ui::DEVICE_FORM_FACTOR_TABLET:
- return "search/pad/";
- default:
- NOTREACHED();
- return std::string();
- }
- }
- } // namespace
- // TemplateURLRef::SearchTermsArgs --------------------------------------------
- TemplateURLRef::SearchTermsArgs::SearchTermsArgs() = default;
- TemplateURLRef::SearchTermsArgs::SearchTermsArgs(
- const std::u16string& search_terms)
- : search_terms(search_terms) {}
- TemplateURLRef::SearchTermsArgs::SearchTermsArgs(const SearchTermsArgs& other) =
- default;
- TemplateURLRef::SearchTermsArgs::~SearchTermsArgs() {
- }
- size_t TemplateURLRef::SearchTermsArgs::EstimateMemoryUsage() const {
- size_t res = 0;
- res += base::trace_event::EstimateMemoryUsage(search_terms);
- res += base::trace_event::EstimateMemoryUsage(original_query);
- res += base::trace_event::EstimateMemoryUsage(assisted_query_stats);
- res += base::trace_event::EstimateMemoryUsage(current_page_url);
- res += base::trace_event::EstimateMemoryUsage(session_token);
- res += base::trace_event::EstimateMemoryUsage(prefetch_query);
- res += base::trace_event::EstimateMemoryUsage(prefetch_query_type);
- res += base::trace_event::EstimateMemoryUsage(additional_query_params);
- res += base::trace_event::EstimateMemoryUsage(image_thumbnail_content);
- res += base::trace_event::EstimateMemoryUsage(image_url);
- res += base::trace_event::EstimateMemoryUsage(contextual_search_params);
- return res;
- }
- TemplateURLRef::SearchTermsArgs::ContextualSearchParams::
- ContextualSearchParams() = default;
- TemplateURLRef::SearchTermsArgs::ContextualSearchParams::ContextualSearchParams(
- int version,
- int contextual_cards_version,
- std::string home_country,
- int64_t previous_event_id,
- int previous_event_results,
- bool is_exact_search,
- std::string source_lang,
- std::string target_lang,
- std::string fluent_languages,
- std::string related_searches_stamp)
- : version(version),
- contextual_cards_version(contextual_cards_version),
- home_country(home_country),
- previous_event_id(previous_event_id),
- previous_event_results(previous_event_results),
- is_exact_search(is_exact_search),
- source_lang(source_lang),
- target_lang(target_lang),
- fluent_languages(fluent_languages),
- related_searches_stamp(related_searches_stamp) {}
- TemplateURLRef::SearchTermsArgs::ContextualSearchParams::ContextualSearchParams(
- const ContextualSearchParams& other) = default;
- TemplateURLRef::SearchTermsArgs::ContextualSearchParams::
- ~ContextualSearchParams() {
- }
- size_t
- TemplateURLRef::SearchTermsArgs::ContextualSearchParams::EstimateMemoryUsage()
- const {
- return base::trace_event::EstimateMemoryUsage(home_country);
- }
- // TemplateURLRef -------------------------------------------------------------
- TemplateURLRef::TemplateURLRef(const TemplateURL* owner, Type type)
- : owner_(owner), type_(type) {
- DCHECK(owner_);
- DCHECK_NE(INDEXED, type_);
- }
- TemplateURLRef::TemplateURLRef(const TemplateURL* owner, size_t index_in_owner)
- : owner_(owner), type_(INDEXED), index_in_owner_(index_in_owner) {
- DCHECK(owner_);
- DCHECK_LT(index_in_owner_, owner_->alternate_urls().size());
- }
- TemplateURLRef::~TemplateURLRef() {
- }
- TemplateURLRef::TemplateURLRef(const TemplateURLRef& source) = default;
- TemplateURLRef& TemplateURLRef::operator=(const TemplateURLRef& source) =
- default;
- std::string TemplateURLRef::GetURL() const {
- switch (type_) {
- case SEARCH: return owner_->url();
- case SUGGEST: return owner_->suggestions_url();
- case IMAGE: return owner_->image_url();
- case NEW_TAB: return owner_->new_tab_url();
- case CONTEXTUAL_SEARCH: return owner_->contextual_search_url();
- case INDEXED: return owner_->alternate_urls()[index_in_owner_];
- default: NOTREACHED(); return std::string(); // NOLINT
- }
- }
- std::string TemplateURLRef::GetPostParamsString() const {
- switch (type_) {
- case INDEXED:
- case SEARCH: return owner_->search_url_post_params();
- case SUGGEST: return owner_->suggestions_url_post_params();
- case NEW_TAB: return std::string();
- case CONTEXTUAL_SEARCH: return std::string();
- case IMAGE: return owner_->image_url_post_params();
- default: NOTREACHED(); return std::string(); // NOLINT
- }
- }
- bool TemplateURLRef::UsesPOSTMethod(
- const SearchTermsData& search_terms_data) const {
- ParseIfNecessary(search_terms_data);
- return !post_params_.empty();
- }
- size_t TemplateURLRef::EstimateMemoryUsage() const {
- size_t res = 0;
- res += base::trace_event::EstimateMemoryUsage(parsed_url_);
- res += base::trace_event::EstimateMemoryUsage(replacements_);
- res += base::trace_event::EstimateMemoryUsage(host_);
- res += base::trace_event::EstimateMemoryUsage(port_);
- res += base::trace_event::EstimateMemoryUsage(path_prefix_);
- res += base::trace_event::EstimateMemoryUsage(path_suffix_);
- res += base::trace_event::EstimateMemoryUsage(search_term_key_);
- res += base::trace_event::EstimateMemoryUsage(search_term_value_prefix_);
- res += base::trace_event::EstimateMemoryUsage(search_term_value_suffix_);
- res += base::trace_event::EstimateMemoryUsage(post_params_);
- res += sizeof(path_wildcard_present_);
- return res;
- }
- size_t TemplateURLRef::PostParam::EstimateMemoryUsage() const {
- size_t res = 0;
- res += base::trace_event::EstimateMemoryUsage(name);
- res += base::trace_event::EstimateMemoryUsage(value);
- res += base::trace_event::EstimateMemoryUsage(content_type);
- return res;
- }
- bool TemplateURLRef::EncodeFormData(const PostParams& post_params,
- PostContent* post_content) const {
- if (post_params.empty())
- return true;
- if (!post_content)
- return false;
- const char kUploadDataMIMEType[] = "multipart/form-data; boundary=";
- // Each name/value pair is stored in a body part which is preceded by a
- // boundary delimiter line.
- std::string boundary = net::GenerateMimeMultipartBoundary();
- // Sets the content MIME type.
- post_content->first = kUploadDataMIMEType;
- post_content->first += boundary;
- // Encodes the post parameters.
- std::string* post_data = &post_content->second;
- post_data->clear();
- for (const auto& param : post_params) {
- DCHECK(!param.name.empty());
- net::AddMultipartValueForUpload(param.name, param.value, boundary,
- param.content_type, post_data);
- }
- net::AddMultipartFinalDelimiterForUpload(boundary, post_data);
- return true;
- }
- bool TemplateURLRef::SupportsReplacement(
- const SearchTermsData& search_terms_data) const {
- ParseIfNecessary(search_terms_data);
- return valid_ && supports_replacements_;
- }
- std::string TemplateURLRef::ReplaceSearchTerms(
- const SearchTermsArgs& search_terms_args,
- const SearchTermsData& search_terms_data,
- PostContent* post_content) const {
- ParseIfNecessary(search_terms_data);
- if (!valid_)
- return std::string();
- std::string url(HandleReplacements(search_terms_args, search_terms_data,
- post_content));
- GURL gurl(url);
- if (!gurl.is_valid())
- return url;
- std::vector<std::string> query_params;
- if (search_terms_args.append_extra_query_params_from_command_line) {
- std::string extra_params(
- base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
- switches::kExtraSearchQueryParams));
- if (!extra_params.empty())
- query_params.push_back(extra_params);
- }
- if (!search_terms_args.additional_query_params.empty())
- query_params.push_back(search_terms_args.additional_query_params);
- if (!gurl.query().empty())
- query_params.push_back(gurl.query());
- if (owner_->created_from_play_api()) {
- // Append attribution parameter to query originating from Play API search
- // engine.
- query_params.push_back("chrome_dse_attribution=1");
- }
- if (query_params.empty())
- return url;
- GURL::Replacements replacements;
- std::string query_str = base::JoinString(query_params, "&");
- replacements.SetQueryStr(query_str);
- return gurl.ReplaceComponents(replacements).possibly_invalid_spec();
- }
- bool TemplateURLRef::IsValid(const SearchTermsData& search_terms_data) const {
- ParseIfNecessary(search_terms_data);
- return valid_;
- }
- std::u16string TemplateURLRef::DisplayURL(
- const SearchTermsData& search_terms_data) const {
- ParseIfNecessary(search_terms_data);
- std::string result(GetURL());
- if (valid_ && !replacements_.empty()) {
- base::ReplaceSubstringsAfterOffset(&result, 0,
- kSearchTermsParameterFull,
- kDisplaySearchTerms);
- base::ReplaceSubstringsAfterOffset(&result, 0,
- kGoogleUnescapedSearchTermsParameterFull,
- kDisplayUnescapedSearchTerms);
- }
- return base::UTF8ToUTF16(result);
- }
- // static
- std::string TemplateURLRef::DisplayURLToURLRef(
- const std::u16string& display_url) {
- std::string result = base::UTF16ToUTF8(display_url);
- base::ReplaceSubstringsAfterOffset(&result, 0,
- kDisplaySearchTerms,
- kSearchTermsParameterFull);
- base::ReplaceSubstringsAfterOffset(&result, 0,
- kDisplayUnescapedSearchTerms,
- kGoogleUnescapedSearchTermsParameterFull);
- return result;
- }
- const std::string& TemplateURLRef::GetHost(
- const SearchTermsData& search_terms_data) const {
- ParseIfNecessary(search_terms_data);
- return host_;
- }
- std::string TemplateURLRef::GetPath(
- const SearchTermsData& search_terms_data) const {
- ParseIfNecessary(search_terms_data);
- return path_prefix_ + path_suffix_;
- }
- const std::string& TemplateURLRef::GetSearchTermKey(
- const SearchTermsData& search_terms_data) const {
- ParseIfNecessary(search_terms_data);
- return search_term_key_;
- }
- url::Parsed::ComponentType TemplateURLRef::GetSearchTermKeyLocation(
- const SearchTermsData& search_terms_data) const {
- ParseIfNecessary(search_terms_data);
- return search_term_key_location_;
- }
- const std::string& TemplateURLRef::GetSearchTermValuePrefix(
- const SearchTermsData& search_terms_data) const {
- ParseIfNecessary(search_terms_data);
- return search_term_value_prefix_;
- }
- const std::string& TemplateURLRef::GetSearchTermValueSuffix(
- const SearchTermsData& search_terms_data) const {
- ParseIfNecessary(search_terms_data);
- return search_term_value_suffix_;
- }
- std::u16string TemplateURLRef::SearchTermToString16(
- const base::StringPiece& term) const {
- const std::vector<std::string>& encodings = owner_->input_encodings();
- std::u16string result;
- base::UnescapeRule::Type unescape_rules =
- base::UnescapeRule::SPACES | base::UnescapeRule::PATH_SEPARATORS |
- base::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS;
- if (search_term_key_location_ != url::Parsed::PATH)
- unescape_rules |= base::UnescapeRule::REPLACE_PLUS_WITH_SPACE;
- std::string unescaped = base::UnescapeURLComponent(term, unescape_rules);
- for (size_t i = 0; i < encodings.size(); ++i) {
- if (base::CodepageToUTF16(unescaped, encodings[i].c_str(),
- base::OnStringConversionError::FAIL, &result))
- return result;
- }
- // Always fall back on UTF-8 if it works.
- if (base::CodepageToUTF16(unescaped, base::kCodepageUTF8,
- base::OnStringConversionError::FAIL, &result))
- return result;
- // When nothing worked, just use the escaped text. We have no idea what the
- // encoding is. We need to substitute spaces for pluses ourselves since we're
- // not sending it through an unescaper.
- result = base::UTF8ToUTF16(term);
- if (unescape_rules & base::UnescapeRule::REPLACE_PLUS_WITH_SPACE)
- std::replace(result.begin(), result.end(), '+', ' ');
- return result;
- }
- bool TemplateURLRef::HasGoogleBaseURLs(
- const SearchTermsData& search_terms_data) const {
- ParseIfNecessary(search_terms_data);
- return std::any_of(replacements_.begin(), replacements_.end(),
- [](const Replacement& replacement) {
- return replacement.type == GOOGLE_BASE_URL ||
- replacement.type == GOOGLE_BASE_SUGGEST_URL;
- });
- }
- bool TemplateURLRef::ExtractSearchTermsFromURL(
- const GURL& url,
- std::u16string* search_terms,
- const SearchTermsData& search_terms_data,
- url::Parsed::ComponentType* search_terms_component,
- url::Component* search_terms_position) const {
- DCHECK(search_terms);
- search_terms->clear();
- ParseIfNecessary(search_terms_data);
- // We need a search term in the template URL to extract something.
- if (search_term_key_.empty() &&
- (search_term_key_location_ != url::Parsed::PATH))
- return false;
- // Host, port, and path must match.
- if ((url.host() != host_) || (url.port() != port_) ||
- (!PathIsEqual(url) && (search_term_key_location_ != url::Parsed::PATH))) {
- return false;
- }
- base::StringPiece source;
- url::Component position;
- if (search_term_key_location_ == url::Parsed::PATH) {
- source = url.path_piece();
- // If the path does not contain the expected prefix and suffix, then this is
- // not a match.
- if (source.size() < (search_term_value_prefix_.size() +
- search_term_value_suffix_.size()) ||
- !base::StartsWith(source, search_term_value_prefix_) ||
- !base::EndsWith(source, search_term_value_suffix_))
- return false;
- position =
- url::MakeRange(search_term_value_prefix_.size(),
- source.length() - search_term_value_suffix_.size());
- } else {
- DCHECK(search_term_key_location_ == url::Parsed::QUERY ||
- search_term_key_location_ == url::Parsed::REF);
- source = (search_term_key_location_ == url::Parsed::QUERY)
- ? url.query_piece()
- : url.ref_piece();
- url::Component query, key, value;
- query.len = static_cast<int>(source.size());
- bool key_found = false;
- while (url::ExtractQueryKeyValue(source.data(), &query, &key, &value)) {
- if (key.is_nonempty()) {
- if (source.substr(key.begin, key.len) == search_term_key_) {
- // Fail if search term key is found twice.
- if (key_found)
- return false;
- // If the query parameter does not contain the expected prefix and
- // suffix, then this is not a match.
- base::StringPiece search_term =
- base::StringPiece(source).substr(value.begin, value.len);
- if (search_term.size() < (search_term_value_prefix_.size() +
- search_term_value_suffix_.size()) ||
- !base::StartsWith(search_term, search_term_value_prefix_) ||
- !base::EndsWith(search_term, search_term_value_suffix_))
- continue;
- key_found = true;
- position =
- url::MakeRange(value.begin + search_term_value_prefix_.size(),
- value.end() - search_term_value_suffix_.size());
- }
- }
- }
- if (!key_found)
- return false;
- }
- // Extract the search term.
- *search_terms =
- SearchTermToString16(source.substr(position.begin, position.len));
- if (search_terms_component)
- *search_terms_component = search_term_key_location_;
- if (search_terms_position)
- *search_terms_position = position;
- return true;
- }
- void TemplateURLRef::InvalidateCachedValues() const {
- supports_replacements_ = valid_ = parsed_ = path_wildcard_present_ = false;
- host_.clear();
- port_.clear();
- path_prefix_.clear();
- path_suffix_.clear();
- search_term_key_.clear();
- search_term_key_location_ = url::Parsed::QUERY;
- search_term_value_prefix_.clear();
- search_term_value_suffix_.clear();
- replacements_.clear();
- post_params_.clear();
- }
- bool TemplateURLRef::ParseParameter(size_t start,
- size_t end,
- std::string* url,
- Replacements* replacements) const {
- DCHECK(start != std::string::npos &&
- end != std::string::npos && end > start);
- size_t length = end - start - 1;
- bool optional = false;
- // Make a copy of |url| that can be referenced in StringPieces below. |url| is
- // modified, so that can't be used in StringPiece.
- const std::string original_url(*url);
- if (original_url[end - 1] == kOptional) {
- optional = true;
- length--;
- }
- const auto parameter =
- base::MakeStringPiece(original_url.begin() + start + 1,
- original_url.begin() + start + 1 + length);
- const auto full_parameter = base::MakeStringPiece(
- original_url.begin() + start, original_url.begin() + end + 1);
- // Remove the parameter from the string. For parameters who replacement is
- // constant and already known, just replace them directly. For other cases,
- // like parameters whose values may change over time, use |replacements|.
- url->erase(start, end - start + 1);
- if (parameter == kSearchTermsParameter) {
- replacements->push_back(Replacement(SEARCH_TERMS, start));
- } else if (parameter == "count") {
- if (!optional)
- url->insert(start, kDefaultCount);
- } else if (parameter == "google:assistedQueryStats") {
- replacements->push_back(Replacement(GOOGLE_ASSISTED_QUERY_STATS, start));
- } else if (parameter == "google:baseURL") {
- replacements->push_back(Replacement(GOOGLE_BASE_URL, start));
- } else if (parameter == "google:baseSearchByImageURL") {
- replacements->push_back(
- Replacement(GOOGLE_BASE_SEARCH_BY_IMAGE_URL, start));
- } else if (parameter == "google:baseSuggestURL") {
- replacements->push_back(Replacement(GOOGLE_BASE_SUGGEST_URL, start));
- } else if (parameter == "google:currentPageUrl") {
- replacements->push_back(Replacement(GOOGLE_CURRENT_PAGE_URL, start));
- } else if (parameter == "google:cursorPosition") {
- replacements->push_back(Replacement(GOOGLE_CURSOR_POSITION, start));
- } else if (parameter == "google:imageOriginalHeight") {
- replacements->push_back(
- Replacement(TemplateURLRef::GOOGLE_IMAGE_ORIGINAL_HEIGHT, start));
- } else if (parameter == "google:imageOriginalWidth") {
- replacements->push_back(
- Replacement(TemplateURLRef::GOOGLE_IMAGE_ORIGINAL_WIDTH, start));
- } else if (parameter == "google:imageSearchSource") {
- replacements->push_back(
- Replacement(TemplateURLRef::GOOGLE_IMAGE_SEARCH_SOURCE, start));
- } else if (parameter == "google:imageThumbnail") {
- replacements->push_back(
- Replacement(TemplateURLRef::GOOGLE_IMAGE_THUMBNAIL, start));
- } else if (parameter == "google:imageThumbnailBase64") {
- replacements->push_back(
- Replacement(TemplateURLRef::GOOGLE_IMAGE_THUMBNAIL_BASE64, start));
- } else if (parameter == "google:imageURL") {
- replacements->push_back(Replacement(TemplateURLRef::GOOGLE_IMAGE_URL,
- start));
- } else if (parameter == "google:inputType") {
- replacements->push_back(Replacement(TemplateURLRef::GOOGLE_INPUT_TYPE,
- start));
- } else if (parameter == "google:omniboxFocusType") {
- replacements->push_back(
- Replacement(TemplateURLRef::GOOGLE_OMNIBOX_FOCUS_TYPE, start));
- } else if (parameter == "google:iOSSearchLanguage") {
- replacements->push_back(Replacement(GOOGLE_IOS_SEARCH_LANGUAGE, start));
- } else if (parameter == "google:contextualSearchVersion") {
- replacements->push_back(
- Replacement(GOOGLE_CONTEXTUAL_SEARCH_VERSION, start));
- } else if (parameter == "google:contextualSearchContextData") {
- replacements->push_back(
- Replacement(GOOGLE_CONTEXTUAL_SEARCH_CONTEXT_DATA, start));
- } else if (parameter == "google:originalQueryForSuggestion") {
- replacements->push_back(Replacement(GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION,
- start));
- } else if (parameter == "google:pageClassification") {
- replacements->push_back(Replacement(GOOGLE_PAGE_CLASSIFICATION, start));
- } else if (parameter == "google:clientCacheTimeToLive") {
- replacements->push_back(
- Replacement(GOOGLE_CLIENT_CACHE_TIME_TO_LIVE, start));
- } else if (parameter == "google:pathWildcard") {
- // Do nothing, we just want the path wildcard removed from the URL.
- } else if (parameter == "google:prefetchQuery") {
- replacements->push_back(Replacement(GOOGLE_PREFETCH_QUERY, start));
- } else if (parameter == "google:prefetchSource") {
- replacements->push_back(Replacement(GOOGLE_PREFETCH_SOURCE, start));
- } else if (parameter == "google:RLZ") {
- replacements->push_back(Replacement(GOOGLE_RLZ, start));
- } else if (parameter == "google:searchboxStats") {
- replacements->push_back(Replacement(GOOGLE_SEARCHBOX_STATS, start));
- } else if (parameter == "google:searchClient") {
- replacements->push_back(Replacement(GOOGLE_SEARCH_CLIENT, start));
- } else if (parameter == "google:searchFieldtrialParameter") {
- replacements->push_back(Replacement(GOOGLE_SEARCH_FIELDTRIAL_GROUP, start));
- } else if (parameter == "google:searchVersion") {
- replacements->push_back(Replacement(GOOGLE_SEARCH_VERSION, start));
- } else if (parameter == "google:sessionToken") {
- replacements->push_back(Replacement(GOOGLE_SESSION_TOKEN, start));
- } else if (parameter == "google:sourceId") {
- #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_IOS)
- url->insert(start, "sourceid=chrome-mobile&");
- #else
- url->insert(start, "sourceid=chrome&");
- #endif
- } else if (parameter == "google:suggestAPIKeyParameter") {
- url->insert(start,
- base::EscapeQueryParamValue(google_apis::GetAPIKey(), false));
- } else if (parameter == "google:suggestClient") {
- replacements->push_back(Replacement(GOOGLE_SUGGEST_CLIENT, start));
- } else if (parameter == "google:suggestRid") {
- replacements->push_back(Replacement(GOOGLE_SUGGEST_REQUEST_ID, start));
- } else if (parameter == kGoogleUnescapedSearchTermsParameter) {
- replacements->push_back(Replacement(GOOGLE_UNESCAPED_SEARCH_TERMS, start));
- } else if (parameter == "yandex:referralID") {
- replacements->push_back(Replacement(YANDEX_REFERRAL_ID, start));
- } else if (parameter == "mailru:referralID") {
- replacements->push_back(Replacement(MAIL_RU_REFERRAL_ID, start));
- } else if (parameter == "yandex:searchPath") {
- url->insert(start, YandexSearchPathFromDeviceFormFactor());
- } else if (parameter == "inputEncoding") {
- replacements->push_back(Replacement(ENCODING, start));
- } else if (parameter == "language") {
- replacements->push_back(Replacement(LANGUAGE, start));
- } else if (parameter == "outputEncoding") {
- if (!optional)
- url->insert(start, kOutputEncodingType);
- } else if ((parameter == "startIndex") || (parameter == "startPage")) {
- // We don't support these.
- if (!optional)
- url->insert(start, "1");
- } else if (!prepopulated_) {
- // If it's a prepopulated URL, we know that it's safe to remove unknown
- // parameters, so just ignore this and return true below. Otherwise it could
- // be some garbage but can also be a javascript block. Put it back.
- url->insert(start, full_parameter.data(), full_parameter.size());
- return false;
- }
- return true;
- }
- std::string TemplateURLRef::ParseURL(const std::string& url,
- Replacements* replacements,
- PostParams* post_params,
- bool* valid) const {
- *valid = false;
- std::string parsed_url = url;
- for (size_t last = 0; last != std::string::npos; ) {
- last = parsed_url.find(kStartParameter, last);
- if (last != std::string::npos) {
- size_t template_end = parsed_url.find(kEndParameter, last);
- if (template_end != std::string::npos) {
- // Since we allow Javascript in the URL, {} pairs could be nested. Match
- // only leaf pairs with supported parameters.
- size_t next_template_start = parsed_url.find(kStartParameter, last + 1);
- if (next_template_start == std::string::npos ||
- next_template_start > template_end) {
- // If successful, ParseParameter erases from the string as such no
- // need to update |last|. If failed, move |last| to the end of pair.
- if (!ParseParameter(last, template_end, &parsed_url, replacements)) {
- // |template_end| + 1 may be beyond the end of the string.
- last = template_end;
- }
- } else {
- last = next_template_start;
- }
- } else {
- // Open brace without a closing brace, return.
- return std::string();
- }
- }
- }
- // Handles the post parameters.
- const std::string& post_params_string = GetPostParamsString();
- if (!post_params_string.empty()) {
- for (const base::StringPiece& cur : base::SplitStringPiece(
- post_params_string, ",",
- base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
- // The '=' delimiter is required and the name must be not empty.
- std::vector<std::string> parts = base::SplitString(
- cur, "=", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
- if ((parts.size() != 2U) || parts[0].empty())
- return std::string();
- std::string& value = parts[1];
- size_t replacements_size = replacements->size();
- if (IsTemplateParameterString(value))
- ParseParameter(0, value.length() - 1, &value, replacements);
- PostParam param = { parts[0], value };
- post_params->push_back(param);
- // If there was a replacement added, points its index to last added
- // PostParam.
- if (replacements->size() > replacements_size) {
- DCHECK_EQ(replacements_size + 1, replacements->size());
- Replacement* r = &replacements->back();
- r->is_post_param = true;
- r->index = post_params->size() - 1;
- }
- }
- DCHECK(!post_params->empty());
- }
- *valid = true;
- return parsed_url;
- }
- void TemplateURLRef::ParseIfNecessary(
- const SearchTermsData& search_terms_data) const {
- if (!parsed_) {
- InvalidateCachedValues();
- parsed_ = true;
- parsed_url_ = ParseURL(GetURL(), &replacements_, &post_params_, &valid_);
- supports_replacements_ = false;
- if (valid_) {
- bool has_only_one_search_term = false;
- for (Replacements::const_iterator i = replacements_.begin();
- i != replacements_.end(); ++i) {
- if ((i->type == SEARCH_TERMS) ||
- (i->type == GOOGLE_UNESCAPED_SEARCH_TERMS)) {
- if (has_only_one_search_term) {
- has_only_one_search_term = false;
- break;
- }
- has_only_one_search_term = true;
- supports_replacements_ = true;
- }
- }
- // Only parse the host/key if there is one search term. Technically there
- // could be more than one term, but it's uncommon; so we punt.
- if (has_only_one_search_term)
- ParseHostAndSearchTermKey(search_terms_data);
- }
- }
- }
- void TemplateURLRef::ParsePath(const std::string& path) const {
- // Wildcard string used when matching URLs.
- const std::string wildcard_escaped = "%7Bgoogle:pathWildcard%7D";
- // We only search for the escaped wildcard because we're only replacing it in
- // the path, and GURL's constructor escapes { and }.
- size_t wildcard_start = path.find(wildcard_escaped);
- path_wildcard_present_ = wildcard_start != std::string::npos;
- path_prefix_ = path.substr(0, wildcard_start);
- path_suffix_ = path_wildcard_present_
- ? path.substr(wildcard_start + wildcard_escaped.length())
- : std::string();
- }
- bool TemplateURLRef::PathIsEqual(const GURL& url) const {
- base::StringPiece path = url.path_piece();
- if (!path_wildcard_present_)
- return path == path_prefix_;
- return ((path.length() >= path_prefix_.length() + path_suffix_.length()) &&
- base::StartsWith(path, path_prefix_) &&
- base::EndsWith(path, path_suffix_));
- }
- void TemplateURLRef::ParseHostAndSearchTermKey(
- const SearchTermsData& search_terms_data) const {
- std::string url_string(GetURL());
- base::ReplaceSubstringsAfterOffset(
- &url_string, 0, "{google:baseURL}",
- search_terms_data.GoogleBaseURLValue());
- base::ReplaceSubstringsAfterOffset(
- &url_string, 0, "{google:baseSuggestURL}",
- search_terms_data.GoogleBaseSuggestURLValue());
- base::ReplaceSubstringsAfterOffset(&url_string, 0, "{yandex:searchPath}",
- YandexSearchPathFromDeviceFormFactor());
- GURL url(url_string);
- if (!url.is_valid())
- return;
- SearchTermLocation query_result(url.query_piece(), url::Parsed::QUERY);
- SearchTermLocation ref_result(url.ref_piece(), url::Parsed::REF);
- SearchTermLocation path_result(url.path_piece(), url::Parsed::PATH);
- const bool in_query = query_result.found();
- const bool in_ref = ref_result.found();
- const bool in_path = path_result.found();
- if (in_query ? (in_ref || in_path) : (in_ref == in_path))
- return; // No key or multiple keys found. We only handle having one key.
- host_ = url.host();
- port_ = url.port();
- if (in_query) {
- search_term_key_location_ = url::Parsed::QUERY;
- search_term_key_ = query_result.key();
- search_term_value_prefix_ = query_result.value_prefix();
- search_term_value_suffix_ = query_result.value_suffix();
- ParsePath(url.path());
- } else if (in_ref) {
- search_term_key_location_ = url::Parsed::REF;
- search_term_key_ = ref_result.key();
- search_term_value_prefix_ = ref_result.value_prefix();
- search_term_value_suffix_ = ref_result.value_suffix();
- ParsePath(url.path());
- } else {
- DCHECK(in_path);
- search_term_key_location_ = url::Parsed::PATH;
- search_term_value_prefix_ = path_result.value_prefix();
- search_term_value_suffix_ = path_result.value_suffix();
- }
- }
- void TemplateURLRef::HandleReplacement(const std::string& name,
- const std::string& value,
- const Replacement& replacement,
- std::string* url) const {
- size_t pos = replacement.index;
- if (replacement.is_post_param) {
- DCHECK_LT(pos, post_params_.size());
- DCHECK(!post_params_[pos].name.empty());
- post_params_[pos].value = value;
- } else {
- url->insert(pos, name.empty() ? value : (name + "=" + value + "&"));
- }
- }
- std::string TemplateURLRef::HandleReplacements(
- const SearchTermsArgs& search_terms_args,
- const SearchTermsData& search_terms_data,
- PostContent* post_content) const {
- if (replacements_.empty()) {
- if (!post_params_.empty())
- EncodeFormData(post_params_, post_content);
- return parsed_url_;
- }
- // Determine if the search terms are in the query or before. We're escaping
- // space as '+' in the former case and as '%20' in the latter case.
- bool is_in_query = true;
- auto search_terms = std::find_if(replacements_.begin(), replacements_.end(),
- [](const Replacement& replacement) {
- return replacement.type == SEARCH_TERMS;
- });
- if (search_terms != replacements_.end()) {
- std::u16string::size_type query_start = parsed_url_.find('?');
- is_in_query = query_start != std::u16string::npos &&
- (static_cast<std::u16string::size_type>(search_terms->index) >
- query_start);
- }
- std::string input_encoding;
- std::u16string encoded_terms;
- std::u16string encoded_original_query;
- owner_->EncodeSearchTerms(search_terms_args, is_in_query, &input_encoding,
- &encoded_terms, &encoded_original_query);
- std::string url = parsed_url_;
- // replacements_ is ordered in ascending order, as such we need to iterate
- // from the back.
- for (const Replacement& replacement : base::Reversed(replacements_)) {
- switch (replacement.type) {
- case ENCODING:
- HandleReplacement(std::string(), input_encoding, replacement, &url);
- break;
- case GOOGLE_CONTEXTUAL_SEARCH_VERSION:
- if (search_terms_args.contextual_search_params.version >= 0) {
- HandleReplacement(
- "ctxs",
- base::NumberToString(
- search_terms_args.contextual_search_params.version),
- replacement, &url);
- }
- break;
- case GOOGLE_CONTEXTUAL_SEARCH_CONTEXT_DATA: {
- DCHECK(!replacement.is_post_param);
- const SearchTermsArgs::ContextualSearchParams& params =
- search_terms_args.contextual_search_params;
- std::vector<std::string> args;
- if (params.contextual_cards_version > 0) {
- args.push_back("ctxsl_coca=" +
- base::NumberToString(params.contextual_cards_version));
- }
- if (!params.home_country.empty())
- args.push_back("ctxs_hc=" + params.home_country);
- if (params.previous_event_id != 0) {
- args.push_back("ctxsl_pid=" +
- base::NumberToString(params.previous_event_id));
- }
- if (params.previous_event_results != 0) {
- args.push_back("ctxsl_per=" +
- base::NumberToString(params.previous_event_results));
- }
- if (params.is_exact_search)
- args.push_back("ctxsl_exact=1");
- if (!params.source_lang.empty())
- args.push_back("tlitesl=" + params.source_lang);
- if (!params.target_lang.empty())
- args.push_back("tlitetl=" + params.target_lang);
- if (!params.fluent_languages.empty())
- args.push_back("ctxs_fls=" + params.fluent_languages);
- if (!params.related_searches_stamp.empty())
- args.push_back("ctxsl_rs=" + params.related_searches_stamp);
- HandleReplacement(std::string(), base::JoinString(args, "&"),
- replacement, &url);
- break;
- }
- case GOOGLE_ASSISTED_QUERY_STATS:
- DCHECK(!replacement.is_post_param);
- if (!search_terms_args.assisted_query_stats.empty()) {
- // Get the base URL without substituting AQS and gs_lcrp to avoid
- // infinite recursion and unwanted replacement respectively. We need
- // the URL to find out if it meets all AQS requirements (e.g. HTTPS
- // protocol check). See TemplateURLRef::SearchTermsArgs for more
- // details.
- SearchTermsArgs sanitized_search_terms_args(search_terms_args);
- sanitized_search_terms_args.assisted_query_stats.clear();
- // Clear the proto. Its empty state has a serialized size of zero.
- sanitized_search_terms_args.searchbox_stats.Clear();
- GURL base_url(ReplaceSearchTerms(sanitized_search_terms_args,
- search_terms_data, nullptr));
- if (base_url.SchemeIsCryptographic() &&
- base::FeatureList::IsEnabled(
- omnibox::kReportAssistedQueryStats)) {
- HandleReplacement("aqs", search_terms_args.assisted_query_stats,
- replacement, &url);
- base::UmaHistogramCounts1000(
- "Omnibox.AssistedQueryStats.Length",
- static_cast<int>(
- search_terms_args.assisted_query_stats.length()));
- }
- }
- break;
- case GOOGLE_SEARCHBOX_STATS: {
- DCHECK(!replacement.is_post_param);
- if (search_terms_args.searchbox_stats.ByteSizeLong() > 0) {
- // Get the base URL without substituting gs_lcrp and AQS to avoid
- // infinite recursion and unwanted replacement respectively. We need
- // the URL to find out if it meets all gs_lcrp requirements (e.g.
- // HTTPS protocol check). See TemplateURLRef::SearchTermsArgs for more
- // details.
- SearchTermsArgs sanitized_search_terms_args(search_terms_args);
- sanitized_search_terms_args.assisted_query_stats.clear();
- // Clear the proto. Its empty state has a serialized size of zero.
- sanitized_search_terms_args.searchbox_stats.Clear();
- GURL base_url(ReplaceSearchTerms(sanitized_search_terms_args,
- search_terms_data, nullptr));
- if (base_url.SchemeIsCryptographic() &&
- base::FeatureList::IsEnabled(omnibox::kReportSearchboxStats)) {
- std::string serialized_searchbox_stats;
- search_terms_args.searchbox_stats.SerializeToString(
- &serialized_searchbox_stats);
- if (!serialized_searchbox_stats.empty()) {
- std::string encoded_searchbox_stats;
- base::Base64UrlEncode(serialized_searchbox_stats,
- base::Base64UrlEncodePolicy::OMIT_PADDING,
- &encoded_searchbox_stats);
- HandleReplacement("gs_lcrp", encoded_searchbox_stats, replacement,
- &url);
- base::UmaHistogramCounts1000(
- "Omnibox.SearchboxStats.Length",
- static_cast<int>(encoded_searchbox_stats.length()));
- }
- }
- }
- break;
- }
- case GOOGLE_BASE_URL:
- DCHECK(!replacement.is_post_param);
- HandleReplacement(std::string(), search_terms_data.GoogleBaseURLValue(),
- replacement, &url);
- break;
- case GOOGLE_BASE_SEARCH_BY_IMAGE_URL:
- DCHECK(!replacement.is_post_param);
- HandleReplacement(std::string(),
- search_terms_data.GoogleBaseSearchByImageURLValue(),
- replacement, &url);
- break;
- case GOOGLE_BASE_SUGGEST_URL:
- DCHECK(!replacement.is_post_param);
- HandleReplacement(std::string(),
- search_terms_data.GoogleBaseSuggestURLValue(),
- replacement, &url);
- break;
- case GOOGLE_CURRENT_PAGE_URL:
- DCHECK(!replacement.is_post_param);
- if (!search_terms_args.current_page_url.empty()) {
- const std::string& escaped_current_page_url =
- base::EscapeQueryParamValue(search_terms_args.current_page_url,
- true);
- HandleReplacement("url", escaped_current_page_url, replacement, &url);
- }
- break;
- case GOOGLE_CURSOR_POSITION:
- DCHECK(!replacement.is_post_param);
- if (search_terms_args.cursor_position != std::u16string::npos)
- HandleReplacement(
- "cp",
- base::StringPrintf("%" PRIuS, search_terms_args.cursor_position),
- replacement, &url);
- break;
- case GOOGLE_INPUT_TYPE:
- DCHECK(!replacement.is_post_param);
- HandleReplacement("oit",
- base::NumberToString(search_terms_args.input_type),
- replacement, &url);
- break;
- case GOOGLE_OMNIBOX_FOCUS_TYPE:
- DCHECK(!replacement.is_post_param);
- if (search_terms_args.focus_type != OmniboxFocusType::DEFAULT) {
- HandleReplacement("oft",
- base::NumberToString(
- static_cast<int>(search_terms_args.focus_type)),
- replacement, &url);
- }
- break;
- case GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION:
- DCHECK(!replacement.is_post_param);
- if (search_terms_args.accepted_suggestion >= 0 ||
- !search_terms_args.assisted_query_stats.empty()) {
- HandleReplacement("oq", base::UTF16ToUTF8(encoded_original_query),
- replacement, &url);
- }
- break;
- case GOOGLE_PAGE_CLASSIFICATION:
- if (search_terms_args.page_classification !=
- metrics::OmniboxEventProto::INVALID_SPEC) {
- HandleReplacement(
- "pgcl",
- base::NumberToString(search_terms_args.page_classification),
- replacement, &url);
- }
- break;
- case GOOGLE_CLIENT_CACHE_TIME_TO_LIVE:
- if (search_terms_args.search_terms.size() == 0 &&
- search_terms_args.zero_suggest_cache_duration_sec > 0) {
- HandleReplacement(
- "ccttl",
- base::NumberToString(
- search_terms_args.zero_suggest_cache_duration_sec),
- replacement, &url);
- }
- break;
- case GOOGLE_PREFETCH_QUERY: {
- const std::string& query = search_terms_args.prefetch_query;
- const std::string& type = search_terms_args.prefetch_query_type;
- if (!query.empty() && !type.empty()) {
- HandleReplacement(std::string(),
- "pfq=" + query + "&qha=" + type + "&", replacement,
- &url);
- }
- break;
- }
- case GOOGLE_PREFETCH_SOURCE: {
- if (search_terms_args.is_prefetch) {
- // Currently, Chrome only support "cs" for prefetches, but if new
- // prefetch sources (outside of suggestions) are added, a new prefetch
- // source value is needed. These should denote the source of the
- // prefetch to allow the search server to treat the requests based on
- // source. "cs" represents Chrome Suggestions as the source. Adding a
- // new source should be supported by the Search engine.
- HandleReplacement("pf", "cs", replacement, &url);
- }
- break;
- }
- case GOOGLE_RLZ: {
- DCHECK(!replacement.is_post_param);
- // On platforms that don't have RLZ, we still want this branch
- // to happen so that we replace the RLZ template with the
- // empty string. (If we don't handle this case, we hit a
- // NOTREACHED below.)
- std::u16string rlz_string = search_terms_data.GetRlzParameterValue(
- search_terms_args.request_source == CROS_APP_LIST);
- if (!rlz_string.empty()) {
- HandleReplacement("rlz", base::UTF16ToUTF8(rlz_string), replacement,
- &url);
- }
- break;
- }
- case GOOGLE_SEARCH_CLIENT: {
- DCHECK(!replacement.is_post_param);
- std::string client = search_terms_data.GetSearchClient();
- if (!client.empty())
- HandleReplacement("client", client, replacement, &url);
- break;
- }
- case GOOGLE_SEARCH_FIELDTRIAL_GROUP:
- // We are not currently running any fieldtrials that modulate the search
- // url. If we do, then we'd have some conditional insert such as:
- // url.insert(replacement.index, used_www ? "gcx=w&" : "gcx=c&");
- break;
- case GOOGLE_SEARCH_VERSION:
- HandleReplacement("gs_rn", "42", replacement, &url);
- break;
- case GOOGLE_SESSION_TOKEN: {
- std::string token = search_terms_args.session_token;
- if (!token.empty())
- HandleReplacement("psi", token, replacement, &url);
- break;
- }
- case GOOGLE_SUGGEST_CLIENT:
- HandleReplacement(
- std::string(),
- search_terms_data.GetSuggestClient(
- search_terms_args.request_source == NON_SEARCHBOX_NTP),
- replacement, &url);
- break;
- case GOOGLE_SUGGEST_REQUEST_ID:
- HandleReplacement(
- std::string(),
- search_terms_data.GetSuggestRequestIdentifier(
- search_terms_args.request_source == NON_SEARCHBOX_NTP),
- replacement, &url);
- break;
- case GOOGLE_UNESCAPED_SEARCH_TERMS: {
- std::string unescaped_terms;
- base::UTF16ToCodepage(search_terms_args.search_terms,
- input_encoding.c_str(),
- base::OnStringConversionError::SKIP,
- &unescaped_terms);
- HandleReplacement(std::string(), unescaped_terms, replacement, &url);
- break;
- }
- case LANGUAGE:
- HandleReplacement(std::string(),
- search_terms_data.GetApplicationLocale(), replacement,
- &url);
- break;
- case SEARCH_TERMS:
- HandleReplacement(std::string(), base::UTF16ToUTF8(encoded_terms),
- replacement, &url);
- break;
- case GOOGLE_IMAGE_THUMBNAIL:
- HandleReplacement(std::string(),
- search_terms_args.image_thumbnail_content,
- replacement, &url);
- if (replacement.is_post_param)
- post_params_[replacement.index].content_type = "image/jpeg";
- break;
- case GOOGLE_IMAGE_THUMBNAIL_BASE64: {
- std::string base64_thumbnail_content;
- base::Base64Encode(search_terms_args.image_thumbnail_content,
- &base64_thumbnail_content);
- HandleReplacement(std::string(), base64_thumbnail_content, replacement,
- &url);
- if (replacement.is_post_param)
- post_params_[replacement.index].content_type = "image/jpeg";
- break;
- }
- case GOOGLE_IMAGE_URL:
- if (search_terms_args.image_url.is_valid()) {
- HandleReplacement(std::string(), search_terms_args.image_url.spec(),
- replacement, &url);
- }
- break;
- case GOOGLE_IMAGE_ORIGINAL_WIDTH:
- if (!search_terms_args.image_original_size.IsEmpty()) {
- HandleReplacement(std::string(),
- base::NumberToString(
- search_terms_args.image_original_size.width()),
- replacement, &url);
- }
- break;
- case GOOGLE_IMAGE_ORIGINAL_HEIGHT:
- if (!search_terms_args.image_original_size.IsEmpty()) {
- HandleReplacement(std::string(),
- base::NumberToString(
- search_terms_args.image_original_size.height()),
- replacement, &url);
- }
- break;
- case GOOGLE_IMAGE_SEARCH_SOURCE:
- HandleReplacement(std::string(),
- search_terms_data.GoogleImageSearchSource(),
- replacement, &url);
- break;
- case GOOGLE_IOS_SEARCH_LANGUAGE:
- #if BUILDFLAG(IS_IOS)
- HandleReplacement("hl", search_terms_data.GetApplicationLocale(),
- replacement, &url);
- #endif
- break;
- case YANDEX_REFERRAL_ID: {
- std::string referral_id = search_terms_data.GetYandexReferralID();
- if (!referral_id.empty())
- HandleReplacement("clid", referral_id, replacement, &url);
- break;
- }
- case MAIL_RU_REFERRAL_ID: {
- std::string referral_id = search_terms_data.GetMailRUReferralID();
- if (!referral_id.empty())
- HandleReplacement("gp", referral_id, replacement, &url);
- break;
- }
- default:
- NOTREACHED();
- break;
- }
- }
- if (!post_params_.empty())
- EncodeFormData(post_params_, post_content);
- return url;
- }
- // TemplateURL ----------------------------------------------------------------
- TemplateURL::AssociatedExtensionInfo::AssociatedExtensionInfo(
- const std::string& extension_id,
- base::Time install_time,
- bool wants_to_be_default_engine)
- : extension_id(extension_id),
- install_time(install_time),
- wants_to_be_default_engine(wants_to_be_default_engine) {}
- TemplateURL::AssociatedExtensionInfo::~AssociatedExtensionInfo() {
- }
- size_t TemplateURL::AssociatedExtensionInfo::EstimateMemoryUsage() const {
- return base::trace_event::EstimateMemoryUsage(extension_id);
- }
- TemplateURL::TemplateURL(const TemplateURLData& data, Type type)
- : data_(data),
- suggestions_url_ref_(this, TemplateURLRef::SUGGEST),
- image_url_ref_(this, TemplateURLRef::IMAGE),
- new_tab_url_ref_(this, TemplateURLRef::NEW_TAB),
- contextual_search_url_ref_(this, TemplateURLRef::CONTEXTUAL_SEARCH),
- type_(type),
- engine_type_(SEARCH_ENGINE_UNKNOWN) {
- ResizeURLRefVector();
- SetPrepopulateId(data_.prepopulate_id);
- }
- TemplateURL::TemplateURL(const TemplateURLData& data,
- Type type,
- std::string extension_id,
- base::Time install_time,
- bool wants_to_be_default_engine)
- : TemplateURL(data, type) {
- DCHECK(type == NORMAL_CONTROLLED_BY_EXTENSION ||
- type == OMNIBOX_API_EXTENSION);
- // Omnibox keywords may not be set as default.
- DCHECK(!wants_to_be_default_engine || type != OMNIBOX_API_EXTENSION) << type;
- DCHECK_EQ(kInvalidTemplateURLID, data.id);
- extension_info_ = std::make_unique<AssociatedExtensionInfo>(
- extension_id, install_time, wants_to_be_default_engine);
- }
- TemplateURL::~TemplateURL() {
- }
- bool TemplateURL::IsBetterThanEngineWithConflictingKeyword(
- const TemplateURL* other) const {
- DCHECK(other);
- auto get_sort_key = [](const TemplateURL* engine) {
- return std::make_tuple(
- // Policy-created engines always win over non-policy created engines.
- engine->created_by_policy(),
- // The integral value of the type enum is used to sort next.
- // This makes extension-controlled engines win.
- engine->type(),
- // For engines with associated extensions; more recently installed
- // extensions win.
- engine->extension_info_ ? engine->extension_info_->install_time
- : base::Time(),
- // Prefer engines that CANNOT be auto-replaced.
- !engine->safe_for_autoreplace(),
- // Prefer engines created by Play API.
- engine->created_from_play_api(),
- // Favor prepopulated engines over other auto-generated engines.
- engine->prepopulate_id() > 0,
- // Favor starter pack engines over other auto-generated engines.
- engine->starter_pack_id() > 0,
- // Favor engines derived from OpenSearch descriptions over
- // autogenerated engines heuristically generated from searchable forms.
- engine->originating_url().is_valid(),
- // More recently modified engines or created engines win.
- engine->last_modified(), engine->date_created(),
- // TODO(tommycli): This should be a tie-breaker than provides a total
- // ordering of all TemplateURLs so that distributed clients resolve
- // conflicts identically. This sync_guid is not globally unique today,
- // so we need to fix that before we can resolve conflicts with this.
- engine->sync_guid());
- };
- // Although normally sort is done by operator<, in this case, we want the
- // BETTER engine to be preceding the worse engine.
- return get_sort_key(this) > get_sort_key(other);
- }
- // static
- std::u16string TemplateURL::GenerateKeyword(const GURL& url) {
- DCHECK(url.is_valid());
- // Strip "www." off the front of the keyword; otherwise the keyword won't work
- // properly. See http://code.google.com/p/chromium/issues/detail?id=6984 .
- // |url|'s hostname may be IDN-encoded. Before generating |keyword| from it,
- // convert to Unicode, so it won't look like a confusing punycode string.
- std::u16string keyword =
- url_formatter::IDNToUnicode(url_formatter::StripWWW(url.host()));
- return base::i18n::ToLower(keyword);
- }
- // static
- GURL TemplateURL::GenerateFaviconURL(const GURL& url) {
- DCHECK(url.is_valid());
- GURL::Replacements rep;
- static const char kFaviconPath[] = "/favicon.ico";
- rep.SetPathStr(kFaviconPath);
- rep.ClearUsername();
- rep.ClearPassword();
- rep.ClearQuery();
- rep.ClearRef();
- return url.ReplaceComponents(rep);
- }
- // static
- bool TemplateURL::MatchesData(const TemplateURL* t_url,
- const TemplateURLData* data,
- const SearchTermsData& search_terms_data) {
- if (!t_url || !data)
- return !t_url && !data;
- return (t_url->short_name() == data->short_name()) &&
- t_url->HasSameKeywordAs(*data, search_terms_data) &&
- (t_url->url() == data->url()) &&
- (t_url->suggestions_url() == data->suggestions_url) &&
- (t_url->image_url() == data->image_url) &&
- (t_url->new_tab_url() == data->new_tab_url) &&
- (t_url->search_url_post_params() == data->search_url_post_params) &&
- (t_url->suggestions_url_post_params() ==
- data->suggestions_url_post_params) &&
- (t_url->image_url_post_params() == data->image_url_post_params) &&
- (t_url->safe_for_autoreplace() == data->safe_for_autoreplace) &&
- (t_url->input_encodings() == data->input_encodings) &&
- (t_url->alternate_urls() == data->alternate_urls);
- }
- std::u16string TemplateURL::AdjustedShortNameForLocaleDirection() const {
- std::u16string bidi_safe_short_name = data_.short_name();
- base::i18n::AdjustStringForLocaleDirection(&bidi_safe_short_name);
- return bidi_safe_short_name;
- }
- bool TemplateURL::SupportsReplacement(
- const SearchTermsData& search_terms_data) const {
- return url_ref().SupportsReplacement(search_terms_data);
- }
- bool TemplateURL::HasGoogleBaseURLs(
- const SearchTermsData& search_terms_data) const {
- if (std::any_of(url_refs_.begin(), url_refs_.end(),
- [&](const TemplateURLRef& ref) {
- return ref.HasGoogleBaseURLs(search_terms_data);
- }))
- return true;
- return suggestions_url_ref_.HasGoogleBaseURLs(search_terms_data) ||
- image_url_ref_.HasGoogleBaseURLs(search_terms_data) ||
- new_tab_url_ref_.HasGoogleBaseURLs(search_terms_data) ||
- contextual_search_url_ref_.HasGoogleBaseURLs(search_terms_data);
- }
- bool TemplateURL::IsGoogleSearchURLWithReplaceableKeyword(
- const SearchTermsData& search_terms_data) const {
- return (type_ == NORMAL) && url_ref().HasGoogleBaseURLs(search_terms_data) &&
- google_util::IsGoogleHostname(base::UTF16ToUTF8(data_.keyword()),
- google_util::DISALLOW_SUBDOMAIN);
- }
- bool TemplateURL::HasSameKeywordAs(
- const TemplateURLData& other,
- const SearchTermsData& search_terms_data) const {
- return (data_.keyword() == other.keyword()) ||
- (IsGoogleSearchURLWithReplaceableKeyword(search_terms_data) &&
- TemplateURL(other).IsGoogleSearchURLWithReplaceableKeyword(
- search_terms_data));
- }
- std::string TemplateURL::GetExtensionId() const {
- DCHECK(extension_info_);
- return extension_info_->extension_id;
- }
- SearchEngineType TemplateURL::GetEngineType(
- const SearchTermsData& search_terms_data) const {
- if (engine_type_ == SEARCH_ENGINE_UNKNOWN) {
- const GURL url = GenerateSearchURL(search_terms_data);
- engine_type_ = url.is_valid() ? SearchEngineUtils::GetEngineType(url)
- : SEARCH_ENGINE_OTHER;
- DCHECK_NE(SEARCH_ENGINE_UNKNOWN, engine_type_);
- }
- return engine_type_;
- }
- BuiltinEngineType TemplateURL::GetBuiltinEngineType() const {
- if (data_.prepopulate_id != 0) {
- return KEYWORD_MODE_PREPOPULATED_ENGINE;
- } else if (data_.starter_pack_id != 0) {
- switch (data_.starter_pack_id) {
- case TemplateURLStarterPackData::kBookmarks:
- return KEYWORD_MODE_STARTER_PACK_BOOKMARKS;
- case TemplateURLStarterPackData::kHistory:
- return KEYWORD_MODE_STARTER_PACK_HISTORY;
- case TemplateURLStarterPackData::kTabs:
- return KEYWORD_MODE_STARTER_PACK_TABS;
- default:
- NOTREACHED();
- return KEYWORD_MODE_NON_BUILT_IN;
- }
- } else {
- return KEYWORD_MODE_NON_BUILT_IN;
- }
- }
- bool TemplateURL::ExtractSearchTermsFromURL(
- const GURL& url,
- const SearchTermsData& search_terms_data,
- std::u16string* search_terms) const {
- return FindSearchTermsInURL(url, search_terms_data, search_terms, nullptr,
- nullptr);
- }
- bool TemplateURL::IsSearchURL(const GURL& url,
- const SearchTermsData& search_terms_data) const {
- std::u16string search_terms;
- return ExtractSearchTermsFromURL(url, search_terms_data, &search_terms) &&
- !search_terms.empty();
- }
- bool TemplateURL::ReplaceSearchTermsInURL(
- const GURL& url,
- const TemplateURLRef::SearchTermsArgs& search_terms_args,
- const SearchTermsData& search_terms_data,
- GURL* result) const {
- // TODO(beaudoin): Use AQS from |search_terms_args| too.
- url::Parsed::ComponentType search_term_component;
- url::Component search_terms_position;
- std::u16string search_terms;
- if (!FindSearchTermsInURL(url, search_terms_data, &search_terms,
- &search_term_component, &search_terms_position)) {
- return false;
- }
- DCHECK(search_terms_position.is_nonempty());
- // Query and ref are encoded in the same way.
- const bool is_in_query = (search_term_component != url::Parsed::PATH);
- std::string input_encoding;
- std::u16string encoded_terms;
- std::u16string encoded_original_query;
- EncodeSearchTerms(search_terms_args, is_in_query, &input_encoding,
- &encoded_terms, &encoded_original_query);
- std::string old_params;
- if (search_term_component == url::Parsed::QUERY) {
- old_params = url.query();
- } else if (search_term_component == url::Parsed::REF) {
- old_params = url.ref();
- } else {
- DCHECK_EQ(search_term_component, url::Parsed::PATH);
- old_params = url.path();
- }
- std::string new_params(old_params, 0, search_terms_position.begin);
- new_params += base::UTF16ToUTF8(encoded_terms);
- new_params += old_params.substr(search_terms_position.end());
- GURL::Replacements replacements;
- if (search_term_component == url::Parsed::QUERY) {
- replacements.SetQueryStr(new_params);
- } else if (search_term_component == url::Parsed::REF) {
- replacements.SetRefStr(new_params);
- } else {
- DCHECK_EQ(search_term_component, url::Parsed::PATH);
- replacements.SetPathStr(new_params);
- }
- *result = url.ReplaceComponents(replacements);
- return true;
- }
- void TemplateURL::EncodeSearchTerms(
- const TemplateURLRef::SearchTermsArgs& search_terms_args,
- bool is_in_query,
- std::string* input_encoding,
- std::u16string* encoded_terms,
- std::u16string* encoded_original_query) const {
- std::vector<std::string> encodings(input_encodings());
- if (!base::Contains(encodings, "UTF-8"))
- encodings.push_back("UTF-8");
- for (auto i = encodings.begin(); i != encodings.end(); ++i) {
- if (TryEncoding(search_terms_args.search_terms,
- search_terms_args.original_query, i->c_str(), is_in_query,
- std::next(i) == encodings.end(), encoded_terms,
- encoded_original_query)) {
- *input_encoding = *i;
- return;
- }
- }
- NOTREACHED();
- }
- GURL TemplateURL::GenerateSearchURL(
- const SearchTermsData& search_terms_data) const {
- if (!url_ref().IsValid(search_terms_data))
- return GURL();
- if (!url_ref().SupportsReplacement(search_terms_data))
- return GURL(url());
- // Use something obscure for the search terms argument so that in the rare
- // case the term replaces the URL it's unlikely another keyword would have the
- // same url.
- // TODO(jnd): Add additional parameters to get post data when the search URL
- // has post parameters.
- return GURL(url_ref().ReplaceSearchTerms(
- TemplateURLRef::SearchTermsArgs(u"blah.blah.blah.blah.blah"),
- search_terms_data, nullptr));
- }
- bool TemplateURL::IsSideSearchSupported() const {
- return !side_search_param().empty();
- }
- GURL TemplateURL::GenerateSideSearchURL(
- const GURL& search_url,
- const std::string& version,
- const SearchTermsData& search_terms_data) const {
- DCHECK(IsSideSearchSupported());
- DCHECK(IsSearchURL(search_url, search_terms_data));
- return net::AppendQueryParameter(search_url, side_search_param(), version);
- }
- void TemplateURL::CopyFrom(const TemplateURL& other) {
- if (this == &other)
- return;
- data_ = other.data_;
- ResizeURLRefVector();
- InvalidateCachedValues();
- SetPrepopulateId(other.data_.prepopulate_id);
- }
- void TemplateURL::SetURL(const std::string& url) {
- data_.SetURL(url);
- engine_type_ = SEARCH_ENGINE_UNKNOWN;
- url_ref().InvalidateCachedValues();
- }
- void TemplateURL::SetPrepopulateId(int id) {
- data_.prepopulate_id = id;
- const bool prepopulated = id > 0;
- for (TemplateURLRef& ref : url_refs_)
- ref.prepopulated_ = prepopulated;
- suggestions_url_ref_.prepopulated_ = prepopulated;
- image_url_ref_.prepopulated_ = prepopulated;
- new_tab_url_ref_.prepopulated_ = prepopulated;
- contextual_search_url_ref_.prepopulated_ = prepopulated;
- }
- void TemplateURL::ResetKeywordIfNecessary(
- const SearchTermsData& search_terms_data,
- bool force) {
- if (IsGoogleSearchURLWithReplaceableKeyword(search_terms_data) || force) {
- DCHECK_NE(OMNIBOX_API_EXTENSION, type_);
- GURL url(GenerateSearchURL(search_terms_data));
- if (url.is_valid())
- data_.SetKeyword(GenerateKeyword(url));
- }
- }
- void TemplateURL::InvalidateCachedValues() const {
- for (const TemplateURLRef& ref : url_refs_)
- ref.InvalidateCachedValues();
- suggestions_url_ref_.InvalidateCachedValues();
- image_url_ref_.InvalidateCachedValues();
- new_tab_url_ref_.InvalidateCachedValues();
- contextual_search_url_ref_.InvalidateCachedValues();
- }
- size_t TemplateURL::EstimateMemoryUsage() const {
- size_t res = 0;
- res += base::trace_event::EstimateMemoryUsage(data_);
- res += base::trace_event::EstimateMemoryUsage(url_refs_);
- res += base::trace_event::EstimateMemoryUsage(suggestions_url_ref_);
- res += base::trace_event::EstimateMemoryUsage(image_url_ref_);
- res += base::trace_event::EstimateMemoryUsage(new_tab_url_ref_);
- res += base::trace_event::EstimateMemoryUsage(contextual_search_url_ref_);
- res += base::trace_event::EstimateMemoryUsage(extension_info_);
- return res;
- }
- void TemplateURL::ResizeURLRefVector() {
- const size_t new_size = data_.alternate_urls.size() + 1;
- if (url_refs_.size() == new_size)
- return;
- url_refs_.clear();
- url_refs_.reserve(new_size);
- for (size_t i = 0; i != data_.alternate_urls.size(); ++i)
- url_refs_.emplace_back(this, i);
- url_refs_.emplace_back(this, TemplateURLRef::SEARCH);
- }
- bool TemplateURL::FindSearchTermsInURL(
- const GURL& url,
- const SearchTermsData& search_terms_data,
- std::u16string* search_terms,
- url::Parsed::ComponentType* search_term_component,
- url::Component* search_terms_position) const {
- DCHECK(search_terms);
- search_terms->clear();
- // Try to match with every pattern.
- for (const TemplateURLRef& ref : url_refs_) {
- if (ref.ExtractSearchTermsFromURL(url, search_terms, search_terms_data,
- search_term_component, search_terms_position)) {
- // If ExtractSearchTermsFromURL() returns true and |search_terms| is empty
- // it means the pattern matched but no search terms were present. In this
- // case we fail immediately without looking for matches in subsequent
- // patterns. This means that given patterns
- // [ "http://foo/#q={searchTerms}", "http://foo/?q={searchTerms}" ],
- // calling ExtractSearchTermsFromURL() on "http://foo/?q=bar#q=' would
- // return false. This is important for at least Google, where such URLs
- // are invalid.
- return !search_terms->empty();
- }
- }
- return false;
- }
|