Add a new entry to omnibox_event.proto to log specific type of contextual suggestions

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/i18n/case_conversion.h"
@@ skipping 322 matching lines @@
   return results_from_cache_;
 }
 
 void ZeroSuggestProvider::AddSuggestResultsToMap(
     const SearchSuggestionParser::SuggestResults& results,
     MatchMap* map) {
   for (size_t i = 0; i < results.size(); ++i)
     AddMatchToMap(results[i], std::string(), i, false, false, map);
 }
 
 AutocompleteMatch ZeroSuggestProvider::NavigationToMatch(

[Mark P, 2017/03/21 19:54:25]

Per my request to make this more general, you'll also need to put analogous code
in
SearchProvider::NavigationToMatch() (so it works for as-you-type suggestions)
and also
BaseSearchProvider::CreateSearchSuggestion() (so it works for query
suggestions).

[gcomanici, 2017/03/22 02:39:03]

Done.

     const SearchSuggestionParser::NavigationResult& navigation) {
   AutocompleteMatch match(this, navigation.relevance(), false,
                           navigation.type());
   match.destination_url = navigation.url();
 
   // Zero suggest results should always omit protocols and never appear bold.
   match.contents = url_formatter::FormatUrl(
       navigation.url(), url_formatter::kFormatUrlOmitAll,
       net::UnescapeRule::SPACES, nullptr, nullptr, nullptr);
   match.fill_into_edit +=
       AutocompleteInput::FormattedStringWithEquivalentMeaning(
           navigation.url(), match.contents, client()->GetSchemeClassifier());
 
   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);
+  match.specific_type_identifier = navigation.specific_type_identifier();
   return match;
 }
 
 void ZeroSuggestProvider::Run(const GURL& suggest_url) {
   if (OmniboxFieldTrial::InZeroSuggestMostVisitedFieldTrial()) {
     most_visited_urls_.clear();
     scoped_refptr<history::TopSites> ts = client()->GetTopSites();
     if (ts) {
       waiting_for_most_visited_urls_request_ = true;
       ts->GetMostVisitedURLs(
@@ skipping 65 matching lines @@
           "Omnibox.ZeroSuggest.MostVisitedResultsCounterfactual",
           most_visited_urls_.size());
     }
     const base::string16 current_query_string16(
         base::ASCIIToUTF16(current_query_));
     for (size_t i = 0; i < most_visited_urls_.size(); i++) {
       const history::MostVisitedURL& url = most_visited_urls_[i];
       SearchSuggestionParser::NavigationResult nav(
           client()->GetSchemeClassifier(), url.url,
           AutocompleteMatchType::NAVSUGGEST, url.title, std::string(), false,
-          relevance, true, current_query_string16);
+          relevance, true, current_query_string16, 0);
       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 SearchSuggestionParser::NavigationResults& nav_results(
       results_.navigation_results);
   for (SearchSuggestionParser::NavigationResults::const_iterator it(
-           nav_results.begin()); it != nav_results.end(); ++it)
+           nav_results.begin());
+       it != nav_results.end(); ++it) {
     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_),
                              history_url_provider_,
@@ skipping 62 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();
     }
   }
 }