OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/search_engines/template_url.h" | 5 #include "chrome/browser/search_engines/template_url.h" |
6 | 6 |
7 #include "base/guid.h" | 7 #include "base/guid.h" |
8 #include "base/i18n/case_conversion.h" | 8 #include "base/i18n/case_conversion.h" |
9 #include "base/i18n/icu_string_conversions.h" | 9 #include "base/i18n/icu_string_conversions.h" |
10 #include "base/i18n/rtl.h" | 10 #include "base/i18n/rtl.h" |
(...skipping 24 matching lines...) Expand all Loading... | |
35 const char kSearchTermsParameter[] = "searchTerms"; | 35 const char kSearchTermsParameter[] = "searchTerms"; |
36 const char kSearchTermsParameterFull[] = "{searchTerms}"; | 36 const char kSearchTermsParameterFull[] = "{searchTerms}"; |
37 const char kCountParameter[] = "count"; | 37 const char kCountParameter[] = "count"; |
38 const char kStartIndexParameter[] = "startIndex"; | 38 const char kStartIndexParameter[] = "startIndex"; |
39 const char kStartPageParameter[] = "startPage"; | 39 const char kStartPageParameter[] = "startPage"; |
40 const char kLanguageParameter[] = "language"; | 40 const char kLanguageParameter[] = "language"; |
41 const char kInputEncodingParameter[] = "inputEncoding"; | 41 const char kInputEncodingParameter[] = "inputEncoding"; |
42 const char kOutputEncodingParameter[] = "outputEncoding"; | 42 const char kOutputEncodingParameter[] = "outputEncoding"; |
43 | 43 |
44 const char kGoogleAcceptedSuggestionParameter[] = "google:acceptedSuggestion"; | 44 const char kGoogleAcceptedSuggestionParameter[] = "google:acceptedSuggestion"; |
45 const char kGoogleAssistedQueryStatsParameter[] = "google:assistedQueryStats"; | |
45 // Host/Domain Google searches are relative to. | 46 // Host/Domain Google searches are relative to. |
46 const char kGoogleBaseURLParameter[] = "google:baseURL"; | 47 const char kGoogleBaseURLParameter[] = "google:baseURL"; |
47 const char kGoogleBaseURLParameterFull[] = "{google:baseURL}"; | 48 const char kGoogleBaseURLParameterFull[] = "{google:baseURL}"; |
48 // Like google:baseURL, but for the Search Suggest capability. | 49 // Like google:baseURL, but for the Search Suggest capability. |
49 const char kGoogleBaseSuggestURLParameter[] = "google:baseSuggestURL"; | 50 const char kGoogleBaseSuggestURLParameter[] = "google:baseSuggestURL"; |
50 const char kGoogleBaseSuggestURLParameterFull[] = "{google:baseSuggestURL}"; | 51 const char kGoogleBaseSuggestURLParameterFull[] = "{google:baseSuggestURL}"; |
51 const char kGoogleInstantEnabledParameter[] = "google:instantEnabledParameter"; | 52 const char kGoogleInstantEnabledParameter[] = "google:instantEnabledParameter"; |
52 const char kGoogleOriginalQueryForSuggestionParameter[] = | 53 const char kGoogleOriginalQueryForSuggestionParameter[] = |
53 "google:originalQueryForSuggestion"; | 54 "google:originalQueryForSuggestion"; |
54 const char kGoogleRLZParameter[] = "google:RLZ"; | 55 const char kGoogleRLZParameter[] = "google:RLZ"; |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
99 base::OnStringConversionError::SKIP, &encoded_original_query)) | 100 base::OnStringConversionError::SKIP, &encoded_original_query)) |
100 return false; | 101 return false; |
101 *escaped_original_query = | 102 *escaped_original_query = |
102 UTF8ToUTF16(net::EscapeQueryParamValue(encoded_original_query, true)); | 103 UTF8ToUTF16(net::EscapeQueryParamValue(encoded_original_query, true)); |
103 return true; | 104 return true; |
104 } | 105 } |
105 | 106 |
106 } // namespace | 107 } // namespace |
107 | 108 |
108 | 109 |
110 // TemplateURLRef::SearchTermsArgs -------------------------------------------- | |
111 | |
112 TemplateURLRef::SearchTermsArgs::SearchTermsArgs(const string16& search_terms) | |
113 : search_terms(search_terms), | |
114 accepted_suggestion(NO_SUGGESTIONS_AVAILABLE) { | |
115 } | |
116 | |
117 | |
109 // TemplateURLRef ------------------------------------------------------------- | 118 // TemplateURLRef ------------------------------------------------------------- |
110 | 119 |
111 TemplateURLRef::TemplateURLRef(TemplateURL* owner, Type type) | 120 TemplateURLRef::TemplateURLRef(TemplateURL* owner, Type type) |
112 : owner_(owner), | 121 : owner_(owner), |
113 type_(type), | 122 type_(type), |
114 parsed_(false), | 123 parsed_(false), |
115 valid_(false), | 124 valid_(false), |
116 supports_replacements_(false), | 125 supports_replacements_(false), |
117 prepopulated_(false) { | 126 prepopulated_(false) { |
118 DCHECK(owner_); | 127 DCHECK(owner_); |
(...skipping 16 matching lines...) Expand all Loading... | |
135 return SupportsReplacementUsingTermsData(search_terms_data); | 144 return SupportsReplacementUsingTermsData(search_terms_data); |
136 } | 145 } |
137 | 146 |
138 bool TemplateURLRef::SupportsReplacementUsingTermsData( | 147 bool TemplateURLRef::SupportsReplacementUsingTermsData( |
139 const SearchTermsData& search_terms_data) const { | 148 const SearchTermsData& search_terms_data) const { |
140 ParseIfNecessaryUsingTermsData(search_terms_data); | 149 ParseIfNecessaryUsingTermsData(search_terms_data); |
141 return valid_ && supports_replacements_; | 150 return valid_ && supports_replacements_; |
142 } | 151 } |
143 | 152 |
144 std::string TemplateURLRef::ReplaceSearchTerms( | 153 std::string TemplateURLRef::ReplaceSearchTerms( |
145 const string16& terms, | 154 const SearchTermsArgs& search_terms_args) const { |
146 int accepted_suggestion, | 155 return ReplaceSearchTermsUsingTermsData( |
147 const string16& original_query_for_suggestion) const { | 156 search_terms_args, UIThreadSearchTermsData(owner_->profile())); |
Peter Kasting
2012/06/19 00:38:08
To fix a clang compile error, you'll need to move
Bart N
2012/06/19 01:30:17
Done.
| |
148 UIThreadSearchTermsData search_terms_data(owner_->profile()); | |
149 return ReplaceSearchTermsUsingTermsData(terms, accepted_suggestion, | |
150 original_query_for_suggestion, search_terms_data); | |
151 } | 157 } |
152 | 158 |
153 std::string TemplateURLRef::ReplaceSearchTermsUsingTermsData( | 159 std::string TemplateURLRef::ReplaceSearchTermsUsingTermsData( |
154 const string16& terms, | 160 const SearchTermsArgs& search_terms_args, |
155 int accepted_suggestion, | |
156 const string16& original_query_for_suggestion, | |
157 const SearchTermsData& search_terms_data) const { | 161 const SearchTermsData& search_terms_data) const { |
158 ParseIfNecessaryUsingTermsData(search_terms_data); | 162 ParseIfNecessaryUsingTermsData(search_terms_data); |
159 if (!valid_) | 163 if (!valid_) |
160 return std::string(); | 164 return std::string(); |
161 | 165 |
162 if (replacements_.empty()) | 166 if (replacements_.empty()) |
163 return parsed_url_; | 167 return parsed_url_; |
164 | 168 |
165 // Determine if the search terms are in the query or before. We're escaping | 169 // Determine if the search terms are in the query or before. We're escaping |
166 // space as '+' in the former case and as '%20' in the latter case. | 170 // space as '+' in the former case and as '%20' in the latter case. |
167 bool is_in_query = true; | 171 bool is_in_query = true; |
168 for (Replacements::iterator i = replacements_.begin(); | 172 for (Replacements::iterator i = replacements_.begin(); |
169 i != replacements_.end(); ++i) { | 173 i != replacements_.end(); ++i) { |
170 if (i->type == SEARCH_TERMS) { | 174 if (i->type == SEARCH_TERMS) { |
171 string16::size_type query_start = parsed_url_.find('?'); | 175 string16::size_type query_start = parsed_url_.find('?'); |
172 is_in_query = query_start != string16::npos && | 176 is_in_query = query_start != string16::npos && |
173 (static_cast<string16::size_type>(i->index) > query_start); | 177 (static_cast<string16::size_type>(i->index) > query_start); |
174 break; | 178 break; |
175 } | 179 } |
176 } | 180 } |
177 | 181 |
178 string16 encoded_terms; | 182 string16 encoded_terms; |
179 string16 encoded_original_query; | 183 string16 encoded_original_query; |
180 std::string input_encoding; | 184 std::string input_encoding; |
181 // Encode the search terms so that we know the encoding. | 185 // Encode the search terms so that we know the encoding. |
182 for (std::vector<std::string>::const_iterator i( | 186 for (std::vector<std::string>::const_iterator i( |
183 owner_->input_encodings().begin()); | 187 owner_->input_encodings().begin()); |
184 i != owner_->input_encodings().end(); ++i) { | 188 i != owner_->input_encodings().end(); ++i) { |
185 if (TryEncoding(terms, original_query_for_suggestion, i->c_str(), | 189 if (TryEncoding(search_terms_args.search_terms, |
190 search_terms_args.original_query, i->c_str(), | |
186 is_in_query, &encoded_terms, &encoded_original_query)) { | 191 is_in_query, &encoded_terms, &encoded_original_query)) { |
187 input_encoding = *i; | 192 input_encoding = *i; |
188 break; | 193 break; |
189 } | 194 } |
190 } | 195 } |
191 if (input_encoding.empty()) { | 196 if (input_encoding.empty()) { |
192 input_encoding = "UTF-8"; | 197 input_encoding = "UTF-8"; |
193 if (!TryEncoding(terms, original_query_for_suggestion, | 198 if (!TryEncoding(search_terms_args.search_terms, |
199 search_terms_args.original_query, | |
194 input_encoding.c_str(), is_in_query, &encoded_terms, | 200 input_encoding.c_str(), is_in_query, &encoded_terms, |
195 &encoded_original_query)) | 201 &encoded_original_query)) |
196 NOTREACHED(); | 202 NOTREACHED(); |
197 } | 203 } |
198 | 204 |
199 std::string url = parsed_url_; | 205 std::string url = parsed_url_; |
200 | 206 |
201 // replacements_ is ordered in ascending order, as such we need to iterate | 207 // replacements_ is ordered in ascending order, as such we need to iterate |
202 // from the back. | 208 // from the back. |
203 for (Replacements::reverse_iterator i = replacements_.rbegin(); | 209 for (Replacements::reverse_iterator i = replacements_.rbegin(); |
204 i != replacements_.rend(); ++i) { | 210 i != replacements_.rend(); ++i) { |
205 switch (i->type) { | 211 switch (i->type) { |
206 case ENCODING: | 212 case ENCODING: |
207 url.insert(i->index, input_encoding); | 213 url.insert(i->index, input_encoding); |
208 break; | 214 break; |
209 | 215 |
216 case GOOGLE_ASSISTED_QUERY_STATS: | |
217 if (!search_terms_args.assisted_query_stats.empty()) { | |
218 url.insert(i->index, "aqs=" + search_terms_args.assisted_query_stats + | |
219 "&"); | |
220 } | |
221 break; | |
222 | |
210 case GOOGLE_ACCEPTED_SUGGESTION: | 223 case GOOGLE_ACCEPTED_SUGGESTION: |
211 if (accepted_suggestion == NO_SUGGESTION_CHOSEN) | 224 if (search_terms_args.accepted_suggestion == NO_SUGGESTION_CHOSEN) { |
212 url.insert(i->index, "aq=f&"); | 225 url.insert(i->index, "aq=f&"); |
213 else if (accepted_suggestion != NO_SUGGESTIONS_AVAILABLE) | 226 } else if (search_terms_args.accepted_suggestion != |
227 NO_SUGGESTIONS_AVAILABLE) { | |
214 url.insert(i->index, | 228 url.insert(i->index, |
215 base::StringPrintf("aq=%d&", accepted_suggestion)); | 229 base::StringPrintf("aq=%d&", |
230 search_terms_args.accepted_suggestion)); | |
231 } | |
216 break; | 232 break; |
217 | 233 |
218 case GOOGLE_BASE_URL: | 234 case GOOGLE_BASE_URL: |
219 url.insert(i->index, search_terms_data.GoogleBaseURLValue()); | 235 url.insert(i->index, search_terms_data.GoogleBaseURLValue()); |
220 break; | 236 break; |
221 | 237 |
222 case GOOGLE_BASE_SUGGEST_URL: | 238 case GOOGLE_BASE_SUGGEST_URL: |
223 url.insert(i->index, search_terms_data.GoogleBaseSuggestURLValue()); | 239 url.insert(i->index, search_terms_data.GoogleBaseSuggestURLValue()); |
224 break; | 240 break; |
225 | 241 |
226 case GOOGLE_INSTANT_ENABLED: | 242 case GOOGLE_INSTANT_ENABLED: |
227 url.insert(i->index, search_terms_data.InstantEnabledParam()); | 243 url.insert(i->index, search_terms_data.InstantEnabledParam()); |
228 break; | 244 break; |
229 | 245 |
230 case GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION: | 246 case GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION: |
231 if (accepted_suggestion >= 0) | 247 if (search_terms_args.accepted_suggestion >= 0 || |
248 !search_terms_args.assisted_query_stats.empty()) { | |
232 url.insert(i->index, "oq=" + UTF16ToUTF8(encoded_original_query) + | 249 url.insert(i->index, "oq=" + UTF16ToUTF8(encoded_original_query) + |
233 "&"); | 250 "&"); |
251 } | |
234 break; | 252 break; |
235 | 253 |
236 case GOOGLE_RLZ: { | 254 case GOOGLE_RLZ: { |
237 // On platforms that don't have RLZ, we still want this branch | 255 // On platforms that don't have RLZ, we still want this branch |
238 // to happen so that we replace the RLZ template with the | 256 // to happen so that we replace the RLZ template with the |
239 // empty string. (If we don't handle this case, we hit a | 257 // empty string. (If we don't handle this case, we hit a |
240 // NOTREACHED below.) | 258 // NOTREACHED below.) |
241 #if defined(ENABLE_RLZ) | 259 #if defined(ENABLE_RLZ) |
242 string16 rlz_string = search_terms_data.GetRlzParameterValue(); | 260 string16 rlz_string = search_terms_data.GetRlzParameterValue(); |
243 if (!rlz_string.empty()) { | 261 if (!rlz_string.empty()) { |
244 url.insert(i->index, "rlz=" + UTF16ToUTF8(rlz_string) + "&"); | 262 url.insert(i->index, "rlz=" + UTF16ToUTF8(rlz_string) + "&"); |
245 } | 263 } |
246 #endif | 264 #endif |
247 break; | 265 break; |
248 } | 266 } |
249 | 267 |
250 case GOOGLE_SEARCH_FIELDTRIAL_GROUP: | 268 case GOOGLE_SEARCH_FIELDTRIAL_GROUP: |
251 if (AutocompleteFieldTrial::InSuggestFieldTrial()) { | 269 if (AutocompleteFieldTrial::InSuggestFieldTrial()) { |
252 // Add something like sugexp=chrome,mod=5 to the URL request. | 270 // Add something like sugexp=chrome,mod=5 to the URL request. |
253 url.insert(i->index, "sugexp=chrome,mod=" + | 271 url.insert(i->index, "sugexp=chrome,mod=" + |
254 AutocompleteFieldTrial::GetSuggestGroupName() + "&"); | 272 AutocompleteFieldTrial::GetSuggestGroupName() + "&"); |
255 } | 273 } |
256 break; | 274 break; |
257 | 275 |
258 case GOOGLE_UNESCAPED_SEARCH_TERMS: { | 276 case GOOGLE_UNESCAPED_SEARCH_TERMS: { |
259 std::string unescaped_terms; | 277 std::string unescaped_terms; |
260 base::UTF16ToCodepage(terms, input_encoding.c_str(), | 278 base::UTF16ToCodepage(search_terms_args.search_terms, |
279 input_encoding.c_str(), | |
261 base::OnStringConversionError::SKIP, | 280 base::OnStringConversionError::SKIP, |
262 &unescaped_terms); | 281 &unescaped_terms); |
263 url.insert(i->index, std::string(unescaped_terms.begin(), | 282 url.insert(i->index, std::string(unescaped_terms.begin(), |
264 unescaped_terms.end())); | 283 unescaped_terms.end())); |
265 break; | 284 break; |
266 } | 285 } |
267 | 286 |
268 case LANGUAGE: | 287 case LANGUAGE: |
269 url.insert(i->index, search_terms_data.GetApplicationLocale()); | 288 url.insert(i->index, search_terms_data.GetApplicationLocale()); |
270 break; | 289 break; |
(...skipping 139 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
410 url->insert(start, "1"); | 429 url->insert(start, "1"); |
411 } else if (parameter == kLanguageParameter) { | 430 } else if (parameter == kLanguageParameter) { |
412 replacements->push_back(Replacement(LANGUAGE, start)); | 431 replacements->push_back(Replacement(LANGUAGE, start)); |
413 } else if (parameter == kInputEncodingParameter) { | 432 } else if (parameter == kInputEncodingParameter) { |
414 replacements->push_back(Replacement(ENCODING, start)); | 433 replacements->push_back(Replacement(ENCODING, start)); |
415 } else if (parameter == kOutputEncodingParameter) { | 434 } else if (parameter == kOutputEncodingParameter) { |
416 if (!optional) | 435 if (!optional) |
417 url->insert(start, kOutputEncodingType); | 436 url->insert(start, kOutputEncodingType); |
418 } else if (parameter == kGoogleAcceptedSuggestionParameter) { | 437 } else if (parameter == kGoogleAcceptedSuggestionParameter) { |
419 replacements->push_back(Replacement(GOOGLE_ACCEPTED_SUGGESTION, start)); | 438 replacements->push_back(Replacement(GOOGLE_ACCEPTED_SUGGESTION, start)); |
439 } else if (parameter == kGoogleAssistedQueryStatsParameter) { | |
440 replacements->push_back(Replacement(GOOGLE_ASSISTED_QUERY_STATS, start)); | |
420 } else if (parameter == kGoogleBaseURLParameter) { | 441 } else if (parameter == kGoogleBaseURLParameter) { |
421 replacements->push_back(Replacement(GOOGLE_BASE_URL, start)); | 442 replacements->push_back(Replacement(GOOGLE_BASE_URL, start)); |
422 } else if (parameter == kGoogleBaseSuggestURLParameter) { | 443 } else if (parameter == kGoogleBaseSuggestURLParameter) { |
423 replacements->push_back(Replacement(GOOGLE_BASE_SUGGEST_URL, start)); | 444 replacements->push_back(Replacement(GOOGLE_BASE_SUGGEST_URL, start)); |
424 } else if (parameter == kGoogleInstantEnabledParameter) { | 445 } else if (parameter == kGoogleInstantEnabledParameter) { |
425 replacements->push_back(Replacement(GOOGLE_INSTANT_ENABLED, start)); | 446 replacements->push_back(Replacement(GOOGLE_INSTANT_ENABLED, start)); |
426 } else if (parameter == kGoogleOriginalQueryForSuggestionParameter) { | 447 } else if (parameter == kGoogleOriginalQueryForSuggestionParameter) { |
427 replacements->push_back(Replacement(GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION, | 448 replacements->push_back(Replacement(GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION, |
428 start)); | 449 start)); |
429 } else if (parameter == kGoogleRLZParameter) { | 450 } else if (parameter == kGoogleRLZParameter) { |
(...skipping 249 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
679 } | 700 } |
680 | 701 |
681 void TemplateURL::ResetKeywordIfNecessary(bool force) { | 702 void TemplateURL::ResetKeywordIfNecessary(bool force) { |
682 if (IsGoogleSearchURLWithReplaceableKeyword() || force) { | 703 if (IsGoogleSearchURLWithReplaceableKeyword() || force) { |
683 DCHECK(!IsExtensionKeyword()); | 704 DCHECK(!IsExtensionKeyword()); |
684 GURL url(TemplateURLService::GenerateSearchURL(this)); | 705 GURL url(TemplateURLService::GenerateSearchURL(this)); |
685 if (url.is_valid()) | 706 if (url.is_valid()) |
686 data_.SetKeyword(TemplateURLService::GenerateKeyword(url)); | 707 data_.SetKeyword(TemplateURLService::GenerateKeyword(url)); |
687 } | 708 } |
688 } | 709 } |
OLD | NEW |