zero_suggest_provider.cc revision 558790d6acca3451cf3a6b497803a5f07d0bec58 
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
3// found in the LICENSE file.
4
5#include "chrome/browser/autocomplete/zero_suggest_provider.h"
6
7#include "base/callback.h"
8#include "base/i18n/case_conversion.h"
9#include "base/json/json_string_value_serializer.h"
10#include "base/metrics/histogram.h"
11#include "base/prefs/pref_service.h"
12#include "base/strings/string16.h"
13#include "base/strings/string_util.h"
14#include "base/strings/utf_string_conversions.h"
15#include "base/time/time.h"
16#include "chrome/browser/autocomplete/autocomplete_input.h"
17#include "chrome/browser/autocomplete/autocomplete_match.h"
18#include "chrome/browser/autocomplete/autocomplete_provider_listener.h"
19#include "chrome/browser/autocomplete/history_url_provider.h"
20#include "chrome/browser/autocomplete/search_provider.h"
21#include "chrome/browser/autocomplete/url_prefix.h"
22#include "chrome/browser/metrics/variations/variations_http_header_provider.h"
23#include "chrome/browser/omnibox/omnibox_field_trial.h"
24#include "chrome/browser/profiles/profile.h"
25#include "chrome/browser/search/search.h"
26#include "chrome/browser/search_engines/template_url_service.h"
27#include "chrome/browser/search_engines/template_url_service_factory.h"
28#include "chrome/browser/sync/profile_sync_service.h"
29#include "chrome/browser/sync/profile_sync_service_factory.h"
30#include "chrome/common/net/url_fixer_upper.h"
31#include "chrome/common/pref_names.h"
32#include "chrome/common/url_constants.h"
33#include "net/base/escape.h"
34#include "net/base/load_flags.h"
35#include "net/base/net_util.h"
36#include "net/http/http_request_headers.h"
37#include "net/http/http_response_headers.h"
38#include "net/url_request/url_fetcher.h"
39#include "net/url_request/url_request_status.h"
40#include "url/gurl.h"
41
42namespace {
43
44// TODO(hfung): The histogram code was copied and modified from
45// search_provider.cc.  Refactor and consolidate the code.
46// We keep track in a histogram how many suggest requests we send, how
47// many suggest requests we invalidate (e.g., due to a user typing
48// another character), and how many replies we receive.
49// *** ADD NEW ENUMS AFTER ALL PREVIOUSLY DEFINED ONES! ***
50//     (excluding the end-of-list enum value)
51// We do not want values of existing enums to change or else it screws
52// up the statistics.
53enum ZeroSuggestRequestsHistogramValue {
54  ZERO_SUGGEST_REQUEST_SENT = 1,
55  ZERO_SUGGEST_REQUEST_INVALIDATED,
56  ZERO_SUGGEST_REPLY_RECEIVED,
57  ZERO_SUGGEST_MAX_REQUEST_HISTOGRAM_VALUE
58};
59
60void LogOmniboxZeroSuggestRequest(
61    ZeroSuggestRequestsHistogramValue request_value) {
62  UMA_HISTOGRAM_ENUMERATION("Omnibox.ZeroSuggestRequests", request_value,
63                            ZERO_SUGGEST_MAX_REQUEST_HISTOGRAM_VALUE);
64}
65
66// The maximum relevance of the top match from this provider.
67const int kDefaultVerbatimZeroSuggestRelevance = 1300;
68
69// Relevance value to use if it was not set explicitly by the server.
70const int kDefaultZeroSuggestRelevance = 100;
71
72}  // namespace
73
74// static
75ZeroSuggestProvider* ZeroSuggestProvider::Create(
76    AutocompleteProviderListener* listener,
77    Profile* profile) {
78  return new ZeroSuggestProvider(listener, profile);
79}
80
81void ZeroSuggestProvider::Start(const AutocompleteInput& input,
82                                bool /*minimal_changes*/) {
83}
84
85void ZeroSuggestProvider::Stop(bool clear_cached_results) {
86  if (have_pending_request_)
87    LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REQUEST_INVALIDATED);
88  have_pending_request_ = false;
89  fetcher_.reset();
90  done_ = true;
91  if (clear_cached_results) {
92    query_matches_map_.clear();
93    navigation_results_.clear();
94    current_query_.clear();
95    matches_.clear();
96  }
97}
98
99void ZeroSuggestProvider::AddProviderInfo(ProvidersInfo* provider_info) const {
100  provider_info->push_back(metrics::OmniboxEventProto_ProviderInfo());
101  metrics::OmniboxEventProto_ProviderInfo& new_entry = provider_info->back();
102  new_entry.set_provider(AsOmniboxEventProviderType());
103  new_entry.set_provider_done(done_);
104  std::vector<uint32> field_trial_hashes;
105  OmniboxFieldTrial::GetActiveSuggestFieldTrialHashes(&field_trial_hashes);
106  for (size_t i = 0; i < field_trial_hashes.size(); ++i) {
107    if (field_trial_triggered_)
108      new_entry.mutable_field_trial_triggered()->Add(field_trial_hashes[i]);
109    if (field_trial_triggered_in_session_) {
110      new_entry.mutable_field_trial_triggered_in_session()->Add(
111          field_trial_hashes[i]);
112     }
113  }
114}
115
116void ZeroSuggestProvider::ResetSession() {
117  // The user has started editing in the omnibox, so leave
118  // |field_trial_triggered_in_session_| unchanged and set
119  // |field_trial_triggered_| to false since zero suggest is inactive now.
120  field_trial_triggered_ = false;
121  Stop(true);
122}
123
124void ZeroSuggestProvider::OnURLFetchComplete(const net::URLFetcher* source) {
125  have_pending_request_ = false;
126  LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REPLY_RECEIVED);
127
128  std::string json_data;
129  source->GetResponseAsString(&json_data);
130  const bool request_succeeded =
131      source->GetStatus().is_success() && source->GetResponseCode() == 200;
132
133  bool have_results = false;
134  if (request_succeeded) {
135    JSONStringValueSerializer deserializer(json_data);
136    deserializer.set_allow_trailing_comma(true);
137    scoped_ptr<Value> data(deserializer.Deserialize(NULL, NULL));
138    if (data.get()) {
139      ParseSuggestResults(*data.get());
140      have_results = !query_matches_map_.empty() ||
141          !navigation_results_.empty();
142    }
143  }
144  done_ = true;
145
146  if (have_results) {
147    ConvertResultsToAutocompleteMatches();
148    listener_->OnProviderUpdate(true);
149  }
150}
151
152void ZeroSuggestProvider::StartZeroSuggest(const GURL& url,
153                                           const string16& permanent_text) {
154  Stop(true);
155  field_trial_triggered_ = false;
156  field_trial_triggered_in_session_ = false;
157  if (!ShouldRunZeroSuggest(url))
158    return;
159  verbatim_relevance_ = kDefaultVerbatimZeroSuggestRelevance;
160  done_ = false;
161  permanent_text_ = permanent_text;
162  current_query_ = url.spec();
163  current_url_match_ = MatchForCurrentURL();
164  // TODO(jered): Consider adding locally-sourced zero-suggestions here too.
165  // These may be useful on the NTP or more relevant to the user than server
166  // suggestions, if based on local browsing history.
167  Run();
168}
169
170ZeroSuggestProvider::ZeroSuggestProvider(
171  AutocompleteProviderListener* listener,
172  Profile* profile)
173    : AutocompleteProvider(listener, profile,
174          AutocompleteProvider::TYPE_ZERO_SUGGEST),
175      template_url_service_(TemplateURLServiceFactory::GetForProfile(profile)),
176      have_pending_request_(false),
177      verbatim_relevance_(kDefaultVerbatimZeroSuggestRelevance),
178      field_trial_triggered_(false),
179      field_trial_triggered_in_session_(false) {
180}
181
182ZeroSuggestProvider::~ZeroSuggestProvider() {
183}
184
185bool ZeroSuggestProvider::ShouldRunZeroSuggest(const GURL& url) const {
186  if (!url.is_valid())
187    return false;
188
189  // Do not query non-http URLs. There will be no useful suggestions for https
190  // or chrome URLs.
191  if (url.scheme() != chrome::kHttpScheme)
192    return false;
193
194  // Don't enable ZeroSuggest until InstantExtended works with ZeroSuggest.
195  if (chrome::IsInstantExtendedAPIEnabled())
196    return false;
197
198  // Don't run if there's no profile or in incognito mode.
199  if (profile_ == NULL || profile_->IsOffTheRecord())
200    return false;
201
202  // Don't run if we can't get preferences or search suggest is not enabled.
203  PrefService* prefs = profile_->GetPrefs();
204  if (prefs == NULL || !prefs->GetBoolean(prefs::kSearchSuggestEnabled))
205    return false;
206
207  ProfileSyncService* service =
208      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
209  browser_sync::SyncPrefs sync_prefs(prefs);
210  // The user has needs to have Chrome Sync enabled (for permissions to
211  // transmit their current URL) and be in the field trial.
212  if (!OmniboxFieldTrial::InZeroSuggestFieldTrial() ||
213      service == NULL ||
214      !service->IsSyncEnabledAndLoggedIn() ||
215      !sync_prefs.HasKeepEverythingSynced()) {
216    return false;
217  }
218  return true;
219}
220
221void ZeroSuggestProvider::FillResults(
222    const Value& root_val,
223    int* verbatim_relevance,
224    SearchProvider::SuggestResults* suggest_results,
225    SearchProvider::NavigationResults* navigation_results) {
226  string16 query;
227  const ListValue* root_list = NULL;
228  const ListValue* results = NULL;
229  const ListValue* relevances = NULL;
230  // The response includes the query, which should be empty for ZeroSuggest
231  // responses.
232  if (!root_val.GetAsList(&root_list) || !root_list->GetString(0, &query) ||
233      (!query.empty()) || !root_list->GetList(1, &results))
234    return;
235
236  // 3rd element: Description list.
237  const ListValue* descriptions = NULL;
238  root_list->GetList(2, &descriptions);
239
240  // 4th element: Disregard the query URL list for now.
241
242  // Reset suggested relevance information from the provider.
243  *verbatim_relevance = kDefaultVerbatimZeroSuggestRelevance;
244
245  // 5th element: Optional key-value pairs from the Suggest server.
246  const ListValue* types = NULL;
247  const DictionaryValue* extras = NULL;
248  if (root_list->GetDictionary(4, &extras)) {
249    extras->GetList("google:suggesttype", &types);
250
251    // Discard this list if its size does not match that of the suggestions.
252    if (extras->GetList("google:suggestrelevance", &relevances) &&
253        relevances->GetSize() != results->GetSize())
254      relevances = NULL;
255    extras->GetInteger("google:verbatimrelevance", verbatim_relevance);
256
257    // Check if the active suggest field trial (if any) has triggered.
258    bool triggered = false;
259    extras->GetBoolean("google:fieldtrialtriggered", &triggered);
260    field_trial_triggered_ |= triggered;
261    field_trial_triggered_in_session_ |= triggered;
262  }
263
264  // Clear the previous results now that new results are available.
265  suggest_results->clear();
266  navigation_results->clear();
267
268  string16 result, title;
269  std::string type;
270  for (size_t index = 0; results->GetString(index, &result); ++index) {
271    // Google search may return empty suggestions for weird input characters,
272    // they make no sense at all and can cause problems in our code.
273    if (result.empty())
274      continue;
275
276    int relevance = kDefaultZeroSuggestRelevance;
277
278    // Apply valid suggested relevance scores; discard invalid lists.
279    if (relevances != NULL && !relevances->GetInteger(index, &relevance))
280      relevances = NULL;
281    if (types && types->GetString(index, &type) && (type == "NAVIGATION")) {
282      // Do not blindly trust the URL coming from the server to be valid.
283      GURL url(URLFixerUpper::FixupURL(UTF16ToUTF8(result), std::string()));
284      if (url.is_valid()) {
285        if (descriptions != NULL)
286          descriptions->GetString(index, &title);
287        navigation_results->push_back(SearchProvider::NavigationResult(
288            *this, url, title, false, relevance, relevances != NULL));
289      }
290    } else {
291      suggest_results->push_back(SearchProvider::SuggestResult(
292          result, false, relevance, relevances != NULL));
293    }
294  }
295}
296
297void ZeroSuggestProvider::AddSuggestResultsToMap(
298    const SearchProvider::SuggestResults& results,
299    const TemplateURL* template_url,
300    SearchProvider::MatchMap* map) {
301  for (size_t i = 0; i < results.size(); ++i) {
302    AddMatchToMap(results[i].relevance(), AutocompleteMatchType::SEARCH_SUGGEST,
303                  template_url, results[i].suggestion(), i, map);
304  }
305}
306
307void ZeroSuggestProvider::AddMatchToMap(int relevance,
308                                        AutocompleteMatch::Type type,
309                                        const TemplateURL* template_url,
310                                        const string16& query_string,
311                                        int accepted_suggestion,
312                                        SearchProvider::MatchMap* map) {
313  // Pass in query_string as the input_text since we don't want any bolding.
314  // TODO(samarth|melevin): use the actual omnibox margin here as well instead
315  // of passing in -1.
316  AutocompleteMatch match = SearchProvider::CreateSearchSuggestion(
317      this, relevance, type, template_url, query_string, query_string,
318      AutocompleteInput(), false, accepted_suggestion, -1, true);
319  if (!match.destination_url.is_valid())
320    return;
321
322  // Try to add |match| to |map|.  If a match for |query_string| is already in
323  // |map|, replace it if |match| is more relevant.
324  // NOTE: Keep this ToLower() call in sync with url_database.cc.
325  const std::pair<SearchProvider::MatchMap::iterator, bool> i(map->insert(
326      std::make_pair(base::i18n::ToLower(query_string), match)));
327  // NOTE: We purposefully do a direct relevance comparison here instead of
328  // using AutocompleteMatch::MoreRelevant(), so that we'll prefer "items added
329  // first" rather than "items alphabetically first" when the scores are equal.
330  // The only case this matters is when a user has results with the same score
331  // that differ only by capitalization; because the history system returns
332  // results sorted by recency, this means we'll pick the most recent such
333  // result even if the precision of our relevance score is too low to
334  // distinguish the two.
335  if (!i.second && (match.relevance > i.first->second.relevance))
336    i.first->second = match;
337}
338
339AutocompleteMatch ZeroSuggestProvider::NavigationToMatch(
340    const SearchProvider::NavigationResult& navigation) {
341  AutocompleteMatch match(this, navigation.relevance(), false,
342                          AutocompleteMatchType::NAVSUGGEST);
343  match.destination_url = navigation.url();
344
345  const std::string languages(
346      profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
347  match.contents = net::FormatUrl(navigation.url(), languages,
348      net::kFormatUrlOmitAll, net::UnescapeRule::SPACES, NULL, NULL, NULL);
349  match.fill_into_edit +=
350      AutocompleteInput::FormattedStringWithEquivalentMeaning(navigation.url(),
351          match.contents);
352
353  AutocompleteMatch::ClassifyLocationInString(string16::npos, 0,
354      match.contents.length(), ACMatchClassification::URL,
355      &match.contents_class);
356
357  match.description =
358      AutocompleteMatch::SanitizeString(navigation.description());
359  AutocompleteMatch::ClassifyLocationInString(string16::npos, 0,
360      match.description.length(), ACMatchClassification::NONE,
361      &match.description_class);
362  return match;
363}
364
365void ZeroSuggestProvider::Run() {
366  have_pending_request_ = false;
367  const int kFetcherID = 1;
368
369  const TemplateURL* default_provider =
370     template_url_service_->GetDefaultSearchProvider();
371  // TODO(hfung): Generalize if the default provider supports zero suggest.
372  // Only make the request if we know that the provider supports zero suggest
373  // (currently only the prepopulated Google provider).
374  if (default_provider == NULL || !default_provider->SupportsReplacement() ||
375      default_provider->prepopulate_id() != 1) {
376    Stop(true);
377    return;
378  }
379  string16 prefix;
380  TemplateURLRef::SearchTermsArgs search_term_args(prefix);
381  search_term_args.zero_prefix_url = current_query_;
382  std::string req_url = default_provider->suggestions_url_ref().
383      ReplaceSearchTerms(search_term_args);
384  GURL suggest_url(req_url);
385  // Make sure we are sending the suggest request through HTTPS.
386  if (!suggest_url.SchemeIs(chrome::kHttpsScheme)) {
387    Stop(true);
388    return;
389  }
390
391  fetcher_.reset(
392      net::URLFetcher::Create(kFetcherID,
393          suggest_url,
394          net::URLFetcher::GET, this));
395  fetcher_->SetRequestContext(profile_->GetRequestContext());
396  fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES);
397  // Add Chrome experiment state to the request headers.
398  net::HttpRequestHeaders headers;
399  chrome_variations::VariationsHttpHeaderProvider::GetInstance()->AppendHeaders(
400      fetcher_->GetOriginalURL(), profile_->IsOffTheRecord(), false, &headers);
401  fetcher_->SetExtraRequestHeaders(headers.ToString());
402
403  fetcher_->Start();
404  have_pending_request_ = true;
405  LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REQUEST_SENT);
406}
407
408void ZeroSuggestProvider::ParseSuggestResults(const Value& root_val) {
409  SearchProvider::SuggestResults suggest_results;
410  FillResults(root_val, &verbatim_relevance_,
411              &suggest_results, &navigation_results_);
412
413  query_matches_map_.clear();
414  AddSuggestResultsToMap(suggest_results,
415                         template_url_service_->GetDefaultSearchProvider(),
416                         &query_matches_map_);
417}
418
419void ZeroSuggestProvider::ConvertResultsToAutocompleteMatches() {
420  matches_.clear();
421
422  const TemplateURL* default_provider =
423      template_url_service_->GetDefaultSearchProvider();
424  // Fail if we can't set the clickthrough URL for query suggestions.
425  if (default_provider == NULL || !default_provider->SupportsReplacement())
426    return;
427
428  const int num_query_results = query_matches_map_.size();
429  const int num_nav_results = navigation_results_.size();
430  const int num_results = num_query_results + num_nav_results;
431  UMA_HISTOGRAM_COUNTS("ZeroSuggest.QueryResults", num_query_results);
432  UMA_HISTOGRAM_COUNTS("ZeroSuggest.URLResults",  num_nav_results);
433  UMA_HISTOGRAM_COUNTS("ZeroSuggest.AllResults", num_results);
434
435  if (num_results == 0)
436    return;
437
438  // TODO(jered): Rip this out once the first match is decoupled from the
439  // current typing in the omnibox.
440  matches_.push_back(current_url_match_);
441
442  for (SearchProvider::MatchMap::const_iterator it(query_matches_map_.begin());
443       it != query_matches_map_.end(); ++it)
444    matches_.push_back(it->second);
445
446  for (SearchProvider::NavigationResults::const_iterator it(
447       navigation_results_.begin()); it != navigation_results_.end(); ++it)
448    matches_.push_back(NavigationToMatch(*it));
449}
450
451AutocompleteMatch ZeroSuggestProvider::MatchForCurrentURL() {
452  AutocompleteInput input(permanent_text_, string16::npos,
453                          string16(), GURL(current_query_),
454                          false, false, true, AutocompleteInput::ALL_MATCHES);
455
456  AutocompleteMatch match(
457      HistoryURLProvider::SuggestExactInput(this, input,
458                                            !HasHTTPScheme(input.text())));
459  match.is_history_what_you_typed_match = false;
460
461  // The placeholder suggestion for the current URL has high relevance so
462  // that it is in the first suggestion slot and inline autocompleted. It
463  // gets dropped as soon as the user types something.
464  match.relevance = verbatim_relevance_;
465
466  return match;
467}
468