Send URLs on non-zero prefix suggest requests also.

chrome/browser/autocomplete/zero_suggest_provider.cc

 // 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/google/google_util.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/browser/sync/profile_sync_service.h"
-#include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/net/url_fixer_upper.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.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/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
@@ skipping 98 matching lines @@
       ParseSuggestResults(*data.get());
   }
   done_ = true;
 
   ConvertResultsToAutocompleteMatches();
   if (!matches_.empty())
     listener_->OnProviderUpdate(true);
 }
 
 void ZeroSuggestProvider::StartZeroSuggest(
-    const GURL& url,
+    const GURL& current_page_url,
     AutocompleteInput::PageClassification page_classification,
     const string16& permanent_text) {
   Stop(true);
   field_trial_triggered_ = false;
   field_trial_triggered_in_session_ = false;
-  if (!ShouldRunZeroSuggest(url, page_classification))
+  permanent_text_ = permanent_text;
+  current_query_ = current_page_url.spec();
+  current_page_classification_ = page_classification;
+  current_url_match_ = MatchForCurrentURL();
+
+  const TemplateURL* default_provider =
+     template_url_service_->GetDefaultSearchProvider();
+  string16 prefix;
+  TemplateURLRef::SearchTermsArgs search_term_args(prefix);
+  search_term_args.current_page_url = current_query_;
+  GURL suggest_url(default_provider->suggestions_url_ref().
+                   ReplaceSearchTerms(search_term_args));
+  if (!SearchProvider::CanSendURL(
+          current_page_url, suggest_url,
+          template_url_service_->GetDefaultSearchProvider(),
+          page_classification, profile_) ||
+      !OmniboxFieldTrial::InZeroSuggestFieldTrial())
     return;
   verbatim_relevance_ = kDefaultVerbatimZeroSuggestRelevance;
   done_ = false;
-  permanent_text_ = permanent_text;
-  current_query_ = url.spec();
-  current_page_classification_ = page_classification;
-  current_url_match_ = MatchForCurrentURL();
   // 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();
+  Run(suggest_url);
 }
 
 ZeroSuggestProvider::ZeroSuggestProvider(
   AutocompleteProviderListener* listener,
   Profile* profile)
     : AutocompleteProvider(listener, profile,
           AutocompleteProvider::TYPE_ZERO_SUGGEST),
       template_url_service_(TemplateURLServiceFactory::GetForProfile(profile)),
       have_pending_request_(false),
       verbatim_relevance_(kDefaultVerbatimZeroSuggestRelevance),
       field_trial_triggered_(false),
       field_trial_triggered_in_session_(false),
       weak_ptr_factory_(this) {
 }
 
 ZeroSuggestProvider::~ZeroSuggestProvider() {
 }
 
-bool ZeroSuggestProvider::ShouldRunZeroSuggest(
-    const GURL& url,
-    AutocompleteInput::PageClassification page_classification) const {
-  if (!ShouldSendURL(url, page_classification))
-    return false;
-
-  // Don't run if there's no profile or in incognito mode.
-  if (profile_ == NULL || profile_->IsOffTheRecord())
-    return false;
-
-  // Don't run if we can't get preferences or search suggest is not enabled.
-  PrefService* prefs = profile_->GetPrefs();
-  if (prefs == NULL || !prefs->GetBoolean(prefs::kSearchSuggestEnabled))
-    return false;
-
-  ProfileSyncService* service =
-      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
-  browser_sync::SyncPrefs sync_prefs(prefs);
-
-  // ZeroSuggest requires sending the current URL to the suggest provider, so we
-  // only want to enable it if the user is willing to have this data sent.
-  // Because tab sync involves sending the same data, we currently use
-  // "tab sync is enabled and tab sync data is unencrypted" as a proxy for
-  // "the user is OK with sending this data".  We might someday want to change
-  // this to a standalone setting or part of some other explicit general opt-in.
-  if (!OmniboxFieldTrial::InZeroSuggestFieldTrial() ||
-      service == NULL ||
-      !service->IsSyncEnabledAndLoggedIn() ||
-      !sync_prefs.GetPreferredDataTypes(syncer::UserTypes()).Has(
-          syncer::PROXY_TABS) ||
-      service->GetEncryptedDataTypes().Has(syncer::SESSIONS)) {
-    return false;
-  }
-  return true;
-}
-
-bool ZeroSuggestProvider::ShouldSendURL(
-    const GURL& url,
-    AutocompleteInput::PageClassification page_classification) const {
-  if (!url.is_valid())
-    return false;
-
-  // TODO(hfung): Show Most Visited on NTP with appropriate verbatim
-  // description when the user actively focuses on the omnibox as discussed in
-  // crbug/305366 if Most Visited (or something similar) will launch.
-  if (page_classification ==
-      AutocompleteInput::INSTANT_NEW_TAB_PAGE_WITH_FAKEBOX_AS_STARTING_FOCUS ||
-      page_classification ==
-      AutocompleteInput::INSTANT_NEW_TAB_PAGE_WITH_OMNIBOX_AS_STARTING_FOCUS)
-    return false;
-
-  // Only allow HTTP URLs or Google HTTPS URLs (including Google search
-  // result pages).  For the latter case, Google was already sent the HTTPS
-  // URLs when requesting the page, so the information is just re-sent.
-  return (url.scheme() == content::kHttpScheme) ||
-      google_util::IsGoogleDomainUrl(url, google_util::ALLOW_SUBDOMAIN,
-                                     google_util::ALLOW_NON_STANDARD_PORTS);
-}
-
 void ZeroSuggestProvider::FillResults(
     const Value& root_val,
     int* verbatim_relevance,
     SearchProvider::SuggestResults* suggest_results,
     SearchProvider::NavigationResults* navigation_results) {
   string16 query;
   const ListValue* root_list = NULL;
   const ListValue* results = NULL;
   const ListValue* relevances = NULL;
   // The response includes the query, which should be empty for ZeroSuggest
@@ skipping 128 matching lines @@
       &match.contents_class);
 
   match.description =
       AutocompleteMatch::SanitizeString(navigation.description());
   AutocompleteMatch::ClassifyLocationInString(string16::npos, 0,
       match.description.length(), ACMatchClassification::NONE,
       &match.description_class);
   return match;
 }
 
-void ZeroSuggestProvider::Run() {
+void ZeroSuggestProvider::Run(const GURL& suggest_url) {
   have_pending_request_ = false;
   const int kFetcherID = 1;
-
-  const TemplateURL* default_provider =
-     template_url_service_->GetDefaultSearchProvider();
-  // TODO(hfung): Generalize if the default provider supports zero suggest.
-  // Only make the request if we know that the provider supports zero suggest
-  // (currently only the prepopulated Google provider).
-  if (default_provider == NULL || !default_provider->SupportsReplacement() ||
-      default_provider->prepopulate_id() != 1) {
-    Stop(true);
-    return;
-  }
-  string16 prefix;
-  TemplateURLRef::SearchTermsArgs search_term_args(prefix);
-  search_term_args.zero_prefix_url = current_query_;
-  std::string req_url = default_provider->suggestions_url_ref().
-      ReplaceSearchTerms(search_term_args);
-  GURL suggest_url(req_url);
-  // Make sure we are sending the suggest request through HTTPS.
-  if (!suggest_url.SchemeIs(content::kHttpsScheme)) {
-    Stop(true);
-    return;
-  }
-
   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);
@@ skipping 94 matching lines @@
   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 = verbatim_relevance_;
 
   return match;
 }