Add title to current page in zero suggest.

components/omnibox/browser/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 "components/omnibox/browser/zero_suggest_provider.h"
 
 #include <stddef.h>
 
 #include "base/callback.h"
+#include "base/feature_list.h"
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics.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 "base/trace_event/trace_event.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
@@ skipping 88 matching lines @@
   if (!input.from_omnibox_focus() || client()->IsOffTheRecord() ||
       input.type() == metrics::OmniboxInputType::INVALID)
     return;
 
   Stop(true, false);
   set_field_trial_triggered(false);
   set_field_trial_triggered_in_session(false);
   results_from_cache_ = false;
   permanent_text_ = input.text();
   current_query_ = input.current_url().spec();
+  current_title_ = input.current_title();
   current_page_classification_ = input.current_page_classification();
   current_url_match_ = MatchForCurrentURL();
 
   std::string url_string = GetContextualSuggestionsUrl();
   GURL suggest_url(url_string);
   if (!suggest_url.is_valid())
     return;
 
   // No need to send the current page URL in personalized suggest or
   // most visited field trials.
@@ skipping 39 matching lines @@
   } else if (!ShouldShowNonContextualZeroSuggest(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.
   MaybeUseCachedSuggestions();
+  LOG(ERROR) << suggest_url.possibly_invalid_spec();

[Mark P, 2017/04/27 05:44:08]

Did you intend to keep this here?  Please reconsider.

[gcomanici, 2017/04/27 17:29:30]

Removed.

   Run(suggest_url);
 }
 
 void ZeroSuggestProvider::Stop(bool clear_cached_results,
                                bool due_to_user_inactivity) {
   if (fetcher_)
     LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REQUEST_INVALIDATED);
   fetcher_.reset();
   waiting_for_most_visited_urls_request_ = false;
   done_ = true;
 
   if (clear_cached_results) {
     // 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 call to Start() to determine the current url
     // match relevance.
     results_.suggest_results.clear();
     results_.navigation_results.clear();
     current_query_.clear();
+    current_title_.clear();
     most_visited_urls_.clear();
   }
 }
 
 void ZeroSuggestProvider::DeleteMatch(const AutocompleteMatch& match) {
   if (OmniboxFieldTrial::InZeroSuggestPersonalizedFieldTrial()) {
     // Remove the deleted match from the cache, so it is not shown to the user
     // again. Since we cannot remove just one result, blow away the cache.
     client()->GetPrefs()->SetString(omnibox::kZeroSuggestCachedResults,
                                     std::string());
@@ skipping 51 matching lines @@
 const TemplateURL* ZeroSuggestProvider::GetTemplateURL(bool is_keyword) const {
   // Zero suggest provider should not receive keyword results.
   DCHECK(!is_keyword);
   return client()->GetTemplateURLService()->GetDefaultSearchProvider();
 }
 
 const AutocompleteInput ZeroSuggestProvider::GetInput(bool is_keyword) const {
   // The callers of this method won't look at the AutocompleteInput's
   // |from_omnibox_focus| member, so we can set its value to false.
   return AutocompleteInput(base::string16(), base::string16::npos,
-                           std::string(), GURL(current_query_),
+                           std::string(), GURL(current_query_), current_title_,
                            current_page_classification_, true, false, false,
                            true, false, client()->GetSchemeClassifier());
 }
 
 bool ZeroSuggestProvider::ShouldAppendExtraParams(
       const SearchSuggestionParser::SuggestResult& result) const {
   // We always use the default provider for search, so append the params.
   return true;
 }
 
@@ skipping 227 matching lines @@
     matches_.push_back(NavigationToMatch(*it));
   }
 }
 
 AutocompleteMatch ZeroSuggestProvider::MatchForCurrentURL() {
   // 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.
   AutocompleteInput tmp(GetInput(false));
   tmp.UpdateText(permanent_text_, base::string16::npos, tmp.parts());
-  return VerbatimMatchForURL(client(), tmp, GURL(current_query_),
+  const base::string16 description =
+      (base::FeatureList::IsEnabled(omnibox::kDisplayTitleForCurrentUrl))
+          ? current_title_
+          : base::string16();
+  return VerbatimMatchForURL(client(), tmp, GURL(current_query_), description,
                              history_url_provider_,
                              results_.verbatim_relevance);
 }
 
 bool ZeroSuggestProvider::ShouldShowNonContextualZeroSuggest(
     const GURL& suggest_url,
     const GURL& current_page_url) const {
   const TemplateURLService* template_url_service =
       client()->GetTemplateURLService();
   if (!ZeroSuggestEnabled(suggest_url,
@@ skipping 53 matching lines @@
   if (!json_data.empty()) {
     std::unique_ptr<base::Value> data(
         SearchSuggestionParser::DeserializeJsonData(json_data));
     if (data && ParseSuggestResults(
             *data, kDefaultZeroSuggestRelevance, false, &results_)) {
       ConvertResultsToAutocompleteMatches();
       results_from_cache_ = !matches_.empty();
     }
   }
 }