Store xsrf token received with psuggest results.

chrome/browser/autocomplete/search_provider.cc

 // Copyright 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/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/callback.h"
@@ skipping 27 matching lines @@
 #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/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_instant_controller.h"
 #include "chrome/browser/ui/search/instant_controller.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 "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.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"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 110 matching lines @@
   }
 
   if (!annotation.empty() && (annotation_start >= match_contents_start))
     match->contents_class.push_back(ACMatchClassification(
         match_contents_end, ACMatchClassification::DIM));
 }
 
 }  // namespace
 
 
+// SuggestionDeletionHandler -------------------------------------------------
+
+// This class handles making requests to the server in order to delete
+// personalized suggestions.
+class SuggestionDeletionHandler : public net::URLFetcherDelegate {
+ public:
+  typedef base::Callback<void(bool, SuggestionDeletionHandler*)>
+      DeletionCompletedCallback;
+
+  SuggestionDeletionHandler(
+      const std::string& deletion_url,
+      Profile* profile,
+      const DeletionCompletedCallback& callback);
+
+  virtual ~SuggestionDeletionHandler();
+
+ private:
+  // net::URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
+
+  scoped_ptr<net::URLFetcher> deletion_fetcher_;
+  DeletionCompletedCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(SuggestionDeletionHandler);
+};
+
+
+SuggestionDeletionHandler::SuggestionDeletionHandler(
+    const std::string& deletion_url,
+    Profile* profile,
+    const DeletionCompletedCallback& callback) : callback_(callback) {
+  GURL url(deletion_url);
+  DCHECK(url.is_valid());
+
+  deletion_fetcher_.reset(net::URLFetcher::Create(
+      SearchProvider::kDeletionURLFetcherID,
+      url,
+      net::URLFetcher::GET,
+      this));
+  deletion_fetcher_->SetRequestContext(profile->GetRequestContext());
+  deletion_fetcher_->Start();
+};
+
+SuggestionDeletionHandler::~SuggestionDeletionHandler() {
+};
+
+void SuggestionDeletionHandler::OnURLFetchComplete(
+    const net::URLFetcher* source) {
+  DCHECK(source == deletion_fetcher_.get());
+  callback_.Run(
+      source->GetStatus().is_success() && (source->GetResponseCode() == 200),
+      this);
+};
+
+
 // SearchProvider::Providers --------------------------------------------------
 
 SearchProvider::Providers::Providers(TemplateURLService* template_url_service)
     : template_url_service_(template_url_service) {
 }
 
 const TemplateURL* SearchProvider::Providers::GetDefaultProviderURL() const {
   return default_provider_.empty() ? NULL :
       template_url_service_->GetTemplateURLForKeyword(default_provider_);
 }
@@ skipping 18 matching lines @@
 }
 
 
 // SearchProvider::SuggestResult ----------------------------------------------
 
 SearchProvider::SuggestResult::SuggestResult(
     const string16& suggestion,
     const string16& match_contents,
     const string16& annotation,
     const std::string& suggest_query_params,
+    const std::string& deletion_url,
     bool from_keyword_provider,
     int relevance,
     bool relevance_from_server,
     bool should_prefetch)
     : Result(from_keyword_provider, relevance, relevance_from_server),
       suggestion_(suggestion),
       match_contents_(match_contents),
       annotation_(annotation),
       suggest_query_params_(suggest_query_params),
+      deletion_url_(deletion_url),
       should_prefetch_(should_prefetch) {
 }
 
 SearchProvider::SuggestResult::~SuggestResult() {
 }
 
 bool SearchProvider::SuggestResult::IsInlineable(const string16& input) const {
   return StartsWith(suggestion_, input, false);
 }
 
@@ skipping 84 matching lines @@
 
   return false;
 }
 
 
 // SearchProvider -------------------------------------------------------------
 
 // static
 const int SearchProvider::kDefaultProviderURLFetcherID = 1;
 const int SearchProvider::kKeywordProviderURLFetcherID = 2;
+const int SearchProvider::kDeletionURLFetcherID = 3;
 int SearchProvider::kMinimumTimeBetweenSuggestQueriesMs = 100;
 const char SearchProvider::kRelevanceFromServerKey[] = "relevance_from_server";
 const char SearchProvider::kShouldPrefetchKey[] = "should_prefetch";
 const char SearchProvider::kSuggestMetadataKey[] = "suggest_metadata";
+const char SearchProvider::kDeletionUrlKey[] = "deletion_url";
 const char SearchProvider::kTrue[] = "true";
 const char SearchProvider::kFalse[] = "false";
 
 SearchProvider::SearchProvider(AutocompleteProviderListener* listener,
                                Profile* profile)
     : AutocompleteProvider(listener, profile,
           AutocompleteProvider::TYPE_SEARCH),
       providers_(TemplateURLServiceFactory::GetForProfile(profile)),
       suggest_results_pending_(0),
       field_trial_triggered_(false),
@@ skipping 84 matching lines @@
   for (size_t i = 0; i < field_trial_hashes.size(); ++i) {
     if (field_trial_triggered_)
       new_entry.mutable_field_trial_triggered()->Add(field_trial_hashes[i]);
     if (field_trial_triggered_in_session_) {
       new_entry.mutable_field_trial_triggered_in_session()->Add(
           field_trial_hashes[i]);
     }
   }
 }
 
+void SearchProvider::DeleteMatch(const AutocompleteMatch& match) {
+  // TODO(mariakhomenko): Add support for deleting search history suggestions.
+  DCHECK(match.deletable);
+
+  deletion_handlers_.push_back(new SuggestionDeletionHandler(
+      match.GetAdditionalInfo(SearchProvider::kDeletionUrlKey),
+      profile_,
+      base::Bind(&SearchProvider::OnDeletionComplete, base::Unretained(this))));
+
+  // Immediately update the list of matches to show the match was deleted,
+  // regardless of whether the server request actually succeeds.
+  DeleteMatchFromMatches(match);
+}
+
 void SearchProvider::ResetSession() {
   field_trial_triggered_in_session_ = false;
 }
 
 SearchProvider::~SearchProvider() {
 }
 
 // static
 void SearchProvider::RemoveStaleResults(const string16& input,
                                         int verbatim_relevance,
@@ skipping 184 matching lines @@
                           elapsed_time);
     }
   }
 
   bool results_updated = false;
   if (request_succeeded) {
     const net::HttpResponseHeaders* const response_headers =
         source->GetResponseHeaders();
     std::string json_data;
     source->GetResponseAsString(&json_data);
+
     // JSON is supposed to be UTF-8, but some suggest service providers send
     // JSON files in non-UTF-8 encodings.  The actual encoding is usually
     // specified in the Content-Type header field.
     if (response_headers) {
       std::string charset;
       if (response_headers->GetCharset(&charset)) {
         string16 data_16;
         // TODO(jungshik): Switch to CodePageToUTF8 after it's added.
         if (base::CodepageToUTF16(json_data, charset.c_str(),
                                   base::OnStringConversionError::FAIL,
@@ skipping 20 matching lines @@
         break;
       }
     }
   }
 
   UpdateMatches();
   if (done_ || results_updated)
     listener_->OnProviderUpdate(results_updated);
 }
 
+void SearchProvider::OnDeletionComplete(bool success,
+                                        SuggestionDeletionHandler* handler) {
+  RecordDeletionResult(success);
+  SuggestionDeletionHandlers::iterator it = std::find(
+      deletion_handlers_.begin(), deletion_handlers_.end(), handler);
+  DCHECK(it != deletion_handlers_.end());
+  deletion_handlers_.erase(it);
+}
+
+
+void SearchProvider::RecordDeletionResult(bool success) {
+  if (success) {
+    content::RecordAction(
+        content::UserMetricsAction("Omnibox.ServerSuggestDelete.Success"));
+  } else {
+    content::RecordAction(
+        content::UserMetricsAction("Omnibox.ServerSuggestDelete.Failure"));
+  }
+}
+
+void SearchProvider::DeleteMatchFromMatches(const AutocompleteMatch& match) {
+  for (ACMatches::iterator i(matches_.begin()); i != matches_.end(); ++i) {
+    // Find the desired match to delete by checking the type and contents.
+    // We can't check the destination URL, because the autocomplete controller
+    // may have reformulated that. Not that while checking for matching
+    // contents works for personalized suggestions, if more match types gain
+    // deletion support, this algorithm may need to be re-examined.
+    if (i->contents == match.contents && i->type == match.type) {
+      matches_.erase(i);
+      break;
+    }
+  }
+  listener_->OnProviderUpdate(true);
+}
+
 void SearchProvider::Run() {
   // Start a new request with the current input.
   suggest_results_pending_ = 0;
   time_suggest_request_sent_ = base::TimeTicks::Now();
 
   default_fetcher_.reset(CreateSuggestFetcher(kDefaultProviderURLFetcherID,
       providers_.GetDefaultProviderURL(), input_));
   keyword_fetcher_.reset(CreateSuggestFetcher(kKeywordProviderURLFetcherID,
       providers_.GetKeywordProviderURL(), keyword_input_));
 
@@ skipping 237 matching lines @@
     NavigationResults* list) {
   for (size_t i = 0; i < list->size(); ++i) {
     NavigationResult& result = (*list)[i];
     result.set_relevance(
         result.CalculateRelevance(input_, providers_.has_keyword_provider()) +
         (list->size() - i - 1));
     result.set_relevance_from_server(false);
   }
 }
 
-bool SearchProvider::CanSendURL(
-    const GURL& current_page_url,
-    const GURL& suggest_url,
-    const TemplateURL* template_url,
-    AutocompleteInput::PageClassification page_classification,
-    Profile* profile) {
-  if (!current_page_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_NTP_WITH_FAKEBOX_AS_STARTING_FOCUS) ||
-      (page_classification ==
-       AutocompleteInput::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS))
-    return false;
-
-  // Only allow HTTP URLs or HTTPS URLs for the same domain as the search
-  // provider.
-  if ((current_page_url.scheme() != content::kHttpScheme) &&
-      ((current_page_url.scheme() != content::kHttpsScheme) ||
-       !net::registry_controlled_domains::SameDomainOrHost(
-           current_page_url, suggest_url,
-           net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES)))
-    return false;
-
-  // Make sure we are sending the suggest request through HTTPS to prevent
-  // exposing the current page URL to networks before the search provider.
-  if (!suggest_url.SchemeIs(content::kHttpsScheme))
-    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->GetBoolean(prefs::kSearchSuggestEnabled))
-    return false;
-
-  // Only make the request if we know that the provider supports zero suggest
-  // (currently only the prepopulated Google provider).
-  if (template_url == NULL || !template_url->SupportsReplacement() ||
-      TemplateURLPrepopulateData::GetEngineType(*template_url) !=
-      SEARCH_ENGINE_GOOGLE)
-    return false;
-
-  // Check field trials and settings allow sending the URL on suggest requests.
-  ProfileSyncService* service =
-      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile);
-  browser_sync::SyncPrefs sync_prefs(prefs);
-  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;
-}
-
 net::URLFetcher* SearchProvider::CreateSuggestFetcher(
     int id,
     const TemplateURL* template_url,
     const AutocompleteInput& input) {
   if (!template_url || template_url->suggestions_url().empty())
     return NULL;
 
   // Bail if the suggestion URL is invalid with the given replacements.
   TemplateURLRef::SearchTermsArgs search_term_args(input.text());
   search_term_args.cursor_position = input.cursor_position();
@@ skipping 113 matching lines @@
         string16 title;
         if (descriptions != NULL)
           descriptions->GetString(index, &title);
         results->navigation_results.push_back(NavigationResult(
             *this, url, title, is_keyword, relevance, true));
       }
     } else {
       bool should_prefetch = static_cast<int>(index) == prefetch_index;
       DictionaryValue* suggestion_detail = NULL;
       string16 match_contents = suggestion;
-      string16 disambiguating_query;
       string16 annotation;
       std::string suggest_query_params;
-      if (suggestion_details && (type == "ENTITY") &&
-          suggestion_details->GetDictionary(index, &suggestion_detail) &&
-          suggestion_detail) {
-        suggestion_detail->GetString("a", &annotation);
-        if (suggestion_detail->GetString("dq", &disambiguating_query) &&
-            !disambiguating_query.empty())
-          suggestion = disambiguating_query;
-        suggestion_detail->GetString("q", &suggest_query_params);
+      std::string deletion_url;
+
+      if (suggestion_details) {
+        suggestion_details->GetDictionary(index, &suggestion_detail);
+        if (suggestion_detail) {
+          suggestion_detail->GetString("du", &deletion_url);
+
+          if (type == "ENTITY") {
+            suggestion_detail->GetString("a", &annotation);
+
+            string16 disambiguating_query;
+            if (suggestion_detail->GetString("dq", &disambiguating_query) &&
+                !disambiguating_query.empty())
+              suggestion = disambiguating_query;
+
+            suggestion_detail->GetString("q", &suggest_query_params);
+          }
+        }
       }
+
       // TODO(kochi): Improve calculator suggestion presentation.
       results->suggest_results.push_back(SuggestResult(
           suggestion, match_contents, annotation, suggest_query_params,
-          is_keyword, relevance, true, should_prefetch));
+          deletion_url, is_keyword, relevance, true, should_prefetch));
     }
   }
 
   // Ignore suggested scores for non-keyword matches in keyword mode; if the
   // server is allowed to score these, it could interfere with the user's
   // ability to get good keyword results.
   const bool abandon_suggested_scores =
       !is_keyword && !providers_.keyword_provider().empty();
   // Apply calculated relevance scores to suggestions if a valid list was
   // not provided or we're abandoning suggested scores entirely.
@@ skipping 39 matching lines @@
                   relevance_from_server,
                   false,
                   std::string(),
                   AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
                   false,
                   input_.text(),
                   string16(),
                   input_.text(),
                   did_not_accept_default_suggestion,
                   std::string(),
+                  std::string(),
                   &map);
   }
   if (!keyword_input_.text().empty()) {
     const TemplateURL* keyword_url = providers_.GetKeywordProviderURL();
     // We only create the verbatim search query match for a keyword
     // if it's not an extension keyword.  Extension keywords are handled
     // in KeywordProvider::Start().  (Extensions are complicated...)
     // Note: in this provider, SEARCH_OTHER_ENGINE must correspond
     // to the keyword verbatim search query.  Do not create other matches
     // of type SEARCH_OTHER_ENGINE.
     if (keyword_url &&
         (keyword_url->GetType() != TemplateURL::OMNIBOX_API_EXTENSION)) {
       bool keyword_relevance_from_server;
       const int keyword_verbatim_relevance =
           GetKeywordVerbatimRelevance(&keyword_relevance_from_server);
       if (keyword_verbatim_relevance > 0) {
         AddMatchToMap(keyword_input_.text(),
                       keyword_verbatim_relevance,
                       keyword_relevance_from_server,
                       false,
                       std::string(),
                       AutocompleteMatchType::SEARCH_OTHER_ENGINE,
                       true,
                       keyword_input_.text(),
                       string16(),
                       keyword_input_.text(),
                       did_not_accept_keyword_suggestion,
                       std::string(),
+                      std::string(),
                       &map);
       }
     }
   }
   AddHistoryResultsToMap(keyword_history_results_, true,
                          did_not_accept_keyword_suggestion, &map);
   AddHistoryResultsToMap(default_history_results_, false,
                          did_not_accept_default_suggestion, &map);
 
   AddSuggestResultsToMap(keyword_results_.suggest_results,
@@ skipping 288 matching lines @@
                   false,
                   false,
                   std::string(),
                   AutocompleteMatchType::SEARCH_HISTORY,
                   is_keyword,
                   i->suggestion(),
                   string16(),
                   i->suggestion(),
                   did_not_accept_suggestion,
                   std::string(),
+                  std::string(),
                   map);
   }
   UMA_HISTOGRAM_TIMES("Omnibox.SearchProvider.AddHistoryResultsTime",
                       base::TimeTicks::Now() - start_time);
 }
 
 SearchProvider::SuggestResults SearchProvider::ScoreHistoryResults(
     const HistoryResults& results,
     bool base_prevent_inline_autocomplete,
     bool input_multiple_words,
@@ skipping 30 matching lines @@
       classifier->Classify(i->term, false, false, &match, NULL);
       prevent_inline_autocomplete =
           !AutocompleteMatch::IsSearchType(match.type);
     }
 
     int relevance = CalculateRelevanceForHistory(
         i->time, is_keyword, !prevent_inline_autocomplete,
         prevent_search_history_inlining);
     scored_results.push_back(
         SuggestResult(i->term, string16(), string16(), std::string(),
-                      is_keyword, relevance, false, false));
+                      std::string(), is_keyword, relevance, false, false));
   }
 
   // History returns results sorted for us.  However, we may have docked some
   // results' scores, so things are no longer in order.  Do a stable sort to get
   // things back in order without otherwise disturbing results with equal
   // scores, then force the scores to be unique, so that the order in which
   // they're shown is deterministic.
   std::stable_sort(scored_results.begin(), scored_results.end(),
                    CompareScoredResults());
   int last_relevance = 0;
@@ skipping 18 matching lines @@
                   results[i].relevance_from_server(),
                   results[i].should_prefetch(),
                   metadata,
                   AutocompleteMatchType::SEARCH_SUGGEST,
                   is_keyword,
                   results[i].match_contents(),
                   results[i].annotation(),
                   results[i].suggestion(),
                   i,
                   results[i].suggest_query_params(),
+                  results[i].deletion_url(),
                   map);
   }
 }
 
 int SearchProvider::GetVerbatimRelevance(bool* relevance_from_server) const {
   // Use the suggested verbatim relevance score if it is non-negative (valid),
   // if inline autocomplete isn't prevented (always show verbatim on backspace),
   // and if it won't suppress verbatim, leaving no default provider matches.
   // Otherwise, if the default provider returned no matches and was still able
   // to suppress verbatim, the user would have no search/nav matches and may be
@@ skipping 104 matching lines @@
                                    bool relevance_from_server,
                                    bool should_prefetch,
                                    const std::string& metadata,
                                    AutocompleteMatch::Type type,
                                    bool is_keyword,
                                    const string16& match_contents,
                                    const string16& annotation,
                                    const string16& query_string,
                                    int accepted_suggestion,
                                    const std::string& suggest_query_params,
+                                   const std::string& deletion_url,
                                    MatchMap* map) {
   // On non-mobile, ask the instant controller for the appropriate start margin.
   // On mobile the start margin is unused, so leave the value as default there.
   int omnibox_start_margin = chrome::kDisableStartMargin;
 #if !defined(OS_ANDROID) && !defined(IOS)
   if (chrome::IsInstantExtendedAPIEnabled()) {
     Browser* browser =
         chrome::FindBrowserWithProfile(profile_, chrome::GetActiveDesktop());
     if (browser && browser->instant_controller() &&
         browser->instant_controller()->instant()) {
@@ skipping 12 matching lines @@
       !is_keyword || providers_.default_provider().empty());
   if (!match.destination_url.is_valid())
     return;
   match.search_terms_args->bookmark_bar_pinned =
       profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
   match.RecordAdditionalInfo(kRelevanceFromServerKey,
                              relevance_from_server ? kTrue : kFalse);
   match.RecordAdditionalInfo(kShouldPrefetchKey,
                              should_prefetch ? kTrue : kFalse);
 
+  if (!deletion_url.empty() && GURL(deletion_url).is_valid()) {
+    match.RecordAdditionalInfo(kDeletionUrlKey, deletion_url);
+    match.deletable = true;
+  }
+
   // Metadata is needed only for prefetching queries.
   if (should_prefetch)
     match.RecordAdditionalInfo(kSuggestMetadataKey, metadata);
 
   // Try to add |match| to |map|.  If a match for |query_string| is already in
   // |map|, replace it if |match| is more relevant.
   // NOTE: Keep this ToLower() call in sync with url_database.cc.
   MatchKey match_key(
       std::make_pair(base::i18n::ToLower(query_string),
                      match.search_terms_args->suggest_query_params));
@@ skipping 145 matching lines @@
     it->set_relevance(max_query_relevance);
     it->set_relevance_from_server(relevance_from_server);
   }
 }
 
 void SearchProvider::UpdateDone() {
   // We're done when the timer isn't running, there are no suggest queries
   // pending, and we're not waiting on Instant.
   done_ = !timer_.IsRunning() && (suggest_results_pending_ == 0);
 }
+
+bool SearchProvider::CanSendURL(
+    const GURL& current_page_url,
+    const GURL& suggest_url,
+    const TemplateURL* template_url,
+    AutocompleteInput::PageClassification page_classification,
+    Profile* profile) {
+  if (!current_page_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_NTP_WITH_FAKEBOX_AS_STARTING_FOCUS) ||
+      (page_classification ==
+       AutocompleteInput::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS))
+    return false;
+
+  // Only allow HTTP URLs or HTTPS URLs for the same domain as the search
+  // provider.
+  if ((current_page_url.scheme() != content::kHttpScheme) &&
+      ((current_page_url.scheme() != content::kHttpsScheme) ||
+       !net::registry_controlled_domains::SameDomainOrHost(
+           current_page_url, suggest_url,
+           net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES)))
+    return false;
+
+  // Make sure we are sending the suggest request through HTTPS to prevent
+  // exposing the current page URL to networks before the search provider.
+  if (!suggest_url.SchemeIs(content::kHttpsScheme))
+    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->GetBoolean(prefs::kSearchSuggestEnabled))
+    return false;
+
+  // Only make the request if we know that the provider supports zero suggest
+  // (currently only the prepopulated Google provider).
+  if (template_url == NULL || !template_url->SupportsReplacement() ||
+      TemplateURLPrepopulateData::GetEngineType(*template_url) !=
+      SEARCH_ENGINE_GOOGLE)
+    return false;
+
+  // Check field trials and settings allow sending the URL on suggest requests.
+  ProfileSyncService* service =
+      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile);
+  browser_sync::SyncPrefs sync_prefs(prefs);
+  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;
+}