1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/autocomplete/zero_suggest_provider.h"
#include "base/callback.h"
#include "base/i18n/case_conversion.h"
#include "base/json/json_string_value_serializer.h"
#include "base/metrics/histogram.h"
#include "base/prefs/pref_service.h"
#include "base/strings/string16.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "chrome/browser/autocomplete/autocomplete_classifier.h"
#include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
#include "chrome/browser/autocomplete/autocomplete_input.h"
#include "chrome/browser/autocomplete/autocomplete_match.h"
#include "chrome/browser/autocomplete/autocomplete_provider_listener.h"
#include "chrome/browser/autocomplete/history_url_provider.h"
#include "chrome/browser/autocomplete/search_provider.h"
#include "chrome/browser/autocomplete/url_prefix.h"
#include "chrome/browser/history/history_types.h"
#include "chrome/browser/history/top_sites.h"
#include "chrome/browser/metrics/variations/variations_http_header_provider.h"
#include "chrome/browser/omnibox/omnibox_field_trial.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/search/search.h"
#include "chrome/browser/search_engines/template_url_service.h"
#include "chrome/browser/search_engines/template_url_service_factory.h"
#include "chrome/common/net/url_fixer_upper.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/url_constants.h"
#include "content/public/browser/user_metrics.h"
#include "net/base/escape.h"
#include "net/base/load_flags.h"
#include "net/base/net_util.h"
#include "net/http/http_request_headers.h"
#include "net/url_request/url_fetcher.h"
#include "net/url_request/url_request_status.h"
#include "url/gurl.h"
namespace {
// TODO(hfung): The histogram code was copied and modified from
// search_provider.cc. Refactor and consolidate the code.
// We keep track in a histogram how many suggest requests we send, how
// many suggest requests we invalidate (e.g., due to a user typing
// another character), and how many replies we receive.
// *** ADD NEW ENUMS AFTER ALL PREVIOUSLY DEFINED ONES! ***
// (excluding the end-of-list enum value)
// We do not want values of existing enums to change or else it screws
// up the statistics.
enum ZeroSuggestRequestsHistogramValue {
ZERO_SUGGEST_REQUEST_SENT = 1,
ZERO_SUGGEST_REQUEST_INVALIDATED,
ZERO_SUGGEST_REPLY_RECEIVED,
ZERO_SUGGEST_MAX_REQUEST_HISTOGRAM_VALUE
};
void LogOmniboxZeroSuggestRequest(
ZeroSuggestRequestsHistogramValue request_value) {
UMA_HISTOGRAM_ENUMERATION("Omnibox.ZeroSuggestRequests", request_value,
ZERO_SUGGEST_MAX_REQUEST_HISTOGRAM_VALUE);
}
// The maximum relevance of the top match from this provider.
const int kDefaultVerbatimZeroSuggestRelevance = 1300;
// Relevance value to use if it was not set explicitly by the server.
const int kDefaultZeroSuggestRelevance = 100;
} // namespace
// static
ZeroSuggestProvider* ZeroSuggestProvider::Create(
AutocompleteProviderListener* listener,
Profile* profile) {
return new ZeroSuggestProvider(listener, profile);
}
void ZeroSuggestProvider::Start(const AutocompleteInput& input,
bool minimal_changes) {
matches_.clear();
if (input.type() == AutocompleteInput::INVALID)
return;
Stop(true);
field_trial_triggered_ = false;
field_trial_triggered_in_session_ = false;
permanent_text_ = input.text();
current_query_ = input.current_url().spec();
current_page_classification_ = input.current_page_classification();
current_url_match_ = MatchForCurrentURL();
const TemplateURL* default_provider =
template_url_service_->GetDefaultSearchProvider();
if (default_provider == NULL)
return;
base::string16 prefix;
TemplateURLRef::SearchTermsArgs search_term_args(prefix);
GURL suggest_url(default_provider->suggestions_url_ref().ReplaceSearchTerms(
search_term_args));
if (!suggest_url.is_valid())
return;
// No need to send the current page URL in personalized suggest field trial.
if (CanSendURL(input.current_url(), suggest_url, default_provider,
current_page_classification_, profile_) &&
!OmniboxFieldTrial::InZeroSuggestPersonalizedFieldTrial()) {
// Update suggest_url to include the current_page_url.
search_term_args.current_page_url = current_query_;
suggest_url = GURL(default_provider->suggestions_url_ref().
ReplaceSearchTerms(search_term_args));
} else if (!CanShowZeroSuggestWithoutSendingURL(suggest_url,
input.current_url())) {
return;
}
done_ = false;
// TODO(jered): Consider adding locally-sourced zero-suggestions here too.
// These may be useful on the NTP or more relevant to the user than server
// suggestions, if based on local browsing history.
Run(suggest_url);
}
void ZeroSuggestProvider::ResetSession() {
// The user has started editing in the omnibox, so leave
// |field_trial_triggered_in_session_| unchanged and set
// |field_trial_triggered_| to false since zero suggest is inactive now.
field_trial_triggered_ = false;
}
ZeroSuggestProvider::ZeroSuggestProvider(
AutocompleteProviderListener* listener,
Profile* profile)
: BaseSearchProvider(listener, profile,
AutocompleteProvider::TYPE_ZERO_SUGGEST),
template_url_service_(TemplateURLServiceFactory::GetForProfile(profile)),
weak_ptr_factory_(this) {
}
ZeroSuggestProvider::~ZeroSuggestProvider() {
}
const TemplateURL* ZeroSuggestProvider::GetTemplateURL(bool is_keyword) const {
// Zero suggest provider should not receive keyword results.
DCHECK(!is_keyword);
return template_url_service_->GetDefaultSearchProvider();
}
const AutocompleteInput ZeroSuggestProvider::GetInput(bool is_keyword) const {
return AutocompleteInput(
base::string16(), base::string16::npos, base::string16(),
GURL(current_query_), current_page_classification_, true, false, false,
true);
}
BaseSearchProvider::Results* ZeroSuggestProvider::GetResultsToFill(
bool is_keyword) {
DCHECK(!is_keyword);
return &results_;
}
bool ZeroSuggestProvider::ShouldAppendExtraParams(
const SuggestResult& result) const {
// We always use the default provider for search, so append the params.
return true;
}
void ZeroSuggestProvider::StopSuggest() {
if (suggest_results_pending_ > 0)
LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REQUEST_INVALIDATED);
suggest_results_pending_ = 0;
fetcher_.reset();
}
void ZeroSuggestProvider::ClearAllResults() {
// We do not call Clear() on |results_| to retain |verbatim_relevance|
// value in the |results_| object. |verbatim_relevance| is used at the
// beginning of the next StartZeroSuggest() call to determine the current url
// match relevance.
results_.suggest_results.clear();
results_.navigation_results.clear();
current_query_.clear();
}
int ZeroSuggestProvider::GetDefaultResultRelevance() const {
return kDefaultZeroSuggestRelevance;
}
void ZeroSuggestProvider::RecordDeletionResult(bool success) {
if (success) {
content::RecordAction(
base::UserMetricsAction("Omnibox.ZeroSuggestDelete.Success"));
} else {
content::RecordAction(
base::UserMetricsAction("Omnibox.ZeroSuggestDelete.Failure"));
}
}
void ZeroSuggestProvider::LogFetchComplete(bool success, bool is_keyword) {
LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REPLY_RECEIVED);
}
bool ZeroSuggestProvider::IsKeywordFetcher(
const net::URLFetcher* fetcher) const {
// ZeroSuggestProvider does not have a keyword provider.
DCHECK_EQ(fetcher, fetcher_.get());
return false;
}
void ZeroSuggestProvider::UpdateMatches() {
done_ = true;
ConvertResultsToAutocompleteMatches();
}
void ZeroSuggestProvider::AddSuggestResultsToMap(
const SuggestResults& results,
MatchMap* map) {
for (size_t i = 0; i < results.size(); ++i)
AddMatchToMap(results[i], std::string(), i, false, map);
}
AutocompleteMatch ZeroSuggestProvider::NavigationToMatch(
const NavigationResult& navigation) {
AutocompleteMatch match(this, navigation.relevance(), false,
AutocompleteMatchType::NAVSUGGEST);
match.destination_url = navigation.url();
// Zero suggest results should always omit protocols and never appear bold.
const std::string languages(
profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
match.contents = net::FormatUrl(navigation.url(), languages,
net::kFormatUrlOmitAll, net::UnescapeRule::SPACES, NULL, NULL, NULL);
match.fill_into_edit +=
AutocompleteInput::FormattedStringWithEquivalentMeaning(navigation.url(),
match.contents);
AutocompleteMatch::ClassifyLocationInString(base::string16::npos, 0,
match.contents.length(), ACMatchClassification::URL,
&match.contents_class);
match.description =
AutocompleteMatch::SanitizeString(navigation.description());
AutocompleteMatch::ClassifyLocationInString(base::string16::npos, 0,
match.description.length(), ACMatchClassification::NONE,
&match.description_class);
return match;
}
void ZeroSuggestProvider::Run(const GURL& suggest_url) {
suggest_results_pending_ = 0;
const int kFetcherID = 1;
fetcher_.reset(
net::URLFetcher::Create(kFetcherID,
suggest_url,
net::URLFetcher::GET, this));
fetcher_->SetRequestContext(profile_->GetRequestContext());
fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES);
// Add Chrome experiment state to the request headers.
net::HttpRequestHeaders headers;
chrome_variations::VariationsHttpHeaderProvider::GetInstance()->AppendHeaders(
fetcher_->GetOriginalURL(), profile_->IsOffTheRecord(), false, &headers);
fetcher_->SetExtraRequestHeaders(headers.ToString());
fetcher_->Start();
if (OmniboxFieldTrial::InZeroSuggestMostVisitedFieldTrial()) {
most_visited_urls_.clear();
history::TopSites* ts = profile_->GetTopSites();
if (ts) {
ts->GetMostVisitedURLs(
base::Bind(&ZeroSuggestProvider::OnMostVisitedUrlsAvailable,
weak_ptr_factory_.GetWeakPtr()), false);
}
}
suggest_results_pending_ = 1;
LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REQUEST_SENT);
}
void ZeroSuggestProvider::OnMostVisitedUrlsAvailable(
const history::MostVisitedURLList& urls) {
most_visited_urls_ = urls;
}
void ZeroSuggestProvider::ConvertResultsToAutocompleteMatches() {
matches_.clear();
const TemplateURL* default_provider =
template_url_service_->GetDefaultSearchProvider();
// Fail if we can't set the clickthrough URL for query suggestions.
if (default_provider == NULL || !default_provider->SupportsReplacement())
return;
MatchMap map;
AddSuggestResultsToMap(results_.suggest_results, &map);
const int num_query_results = map.size();
const int num_nav_results = results_.navigation_results.size();
const int num_results = num_query_results + num_nav_results;
UMA_HISTOGRAM_COUNTS("ZeroSuggest.QueryResults", num_query_results);
UMA_HISTOGRAM_COUNTS("ZeroSuggest.URLResults", num_nav_results);
UMA_HISTOGRAM_COUNTS("ZeroSuggest.AllResults", num_results);
// Show Most Visited results after ZeroSuggest response is received.
if (OmniboxFieldTrial::InZeroSuggestMostVisitedFieldTrial()) {
if (!current_url_match_.destination_url.is_valid())
return;
matches_.push_back(current_url_match_);
int relevance = 600;
if (num_results > 0) {
UMA_HISTOGRAM_COUNTS(
"Omnibox.ZeroSuggest.MostVisitedResultsCounterfactual",
most_visited_urls_.size());
}
const base::string16 current_query_string16(
base::ASCIIToUTF16(current_query_));
const std::string languages(
profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
for (size_t i = 0; i < most_visited_urls_.size(); i++) {
const history::MostVisitedURL& url = most_visited_urls_[i];
NavigationResult nav(*this, url.url, url.title, false, relevance, true,
current_query_string16, languages);
matches_.push_back(NavigationToMatch(nav));
--relevance;
}
return;
}
if (num_results == 0)
return;
// TODO(jered): Rip this out once the first match is decoupled from the
// current typing in the omnibox.
matches_.push_back(current_url_match_);
for (MatchMap::const_iterator it(map.begin()); it != map.end(); ++it)
matches_.push_back(it->second);
const NavigationResults& nav_results(results_.navigation_results);
for (NavigationResults::const_iterator it(nav_results.begin());
it != nav_results.end(); ++it)
matches_.push_back(NavigationToMatch(*it));
}
AutocompleteMatch ZeroSuggestProvider::MatchForCurrentURL() {
AutocompleteMatch match;
AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(
permanent_text_, false, true, current_page_classification_, &match, NULL);
match.is_history_what_you_typed_match = false;
match.allowed_to_be_default_match = true;
// The placeholder suggestion for the current URL has high relevance so
// that it is in the first suggestion slot and inline autocompleted. It
// gets dropped as soon as the user types something.
match.relevance = GetVerbatimRelevance();
return match;
}
int ZeroSuggestProvider::GetVerbatimRelevance() const {
return results_.verbatim_relevance >= 0 ?
results_.verbatim_relevance : kDefaultVerbatimZeroSuggestRelevance;
}
bool ZeroSuggestProvider::CanShowZeroSuggestWithoutSendingURL(
const GURL& suggest_url,
const GURL& current_page_url) const {
if (!ZeroSuggestEnabled(suggest_url,
template_url_service_->GetDefaultSearchProvider(),
current_page_classification_, profile_))
return false;
// If we cannot send URLs, then only the MostVisited and Personalized
// variations can be shown.
if (!OmniboxFieldTrial::InZeroSuggestMostVisitedFieldTrial() &&
!OmniboxFieldTrial::InZeroSuggestPersonalizedFieldTrial())
return false;
// Only show zero suggest for HTTP[S] pages.
// TODO(mariakhomenko): We may be able to expand this set to include pages
// with other schemes (e.g. chrome://). That may require improvements to
// the formatting of the verbatim result returned by MatchForCurrentURL().
if (!current_page_url.is_valid() ||
((current_page_url.scheme() != content::kHttpScheme) &&
(current_page_url.scheme() != content::kHttpsScheme)))
return false;
return true;
}
|