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

components/omnibox/browser/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 "components/omnibox/browser/search_provider.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <cmath>
 #include <utility>
@@ skipping 945 matching lines @@
       if (it->answer &&
           base::i18n::ToLower(it->fill_into_edit) == trimmed_verbatim_lower) {
         answer_contents = it->answer_contents;
         answer_type = it->answer_type;
         answer = SuggestionAnswer::copy(it->answer.get());
         break;
       }
     }
 
     SearchSuggestionParser::SuggestResult verbatim(
-        trimmed_verbatim, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+        trimmed_verbatim, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, 0,
         trimmed_verbatim, base::string16(), base::string16(), answer_contents,
         answer_type, std::move(answer), std::string(), std::string(), false,
         verbatim_relevance, relevance_from_server, false, trimmed_verbatim);
     AddMatchToMap(verbatim, std::string(), did_not_accept_default_suggestion,
                   false, keyword_url != NULL, &map);
   }
   if (!keyword_input_.text().empty()) {
     // 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->type() != TemplateURL::OMNIBOX_API_EXTENSION)) {
       bool keyword_relevance_from_server;
       const int keyword_verbatim_relevance =
           GetKeywordVerbatimRelevance(&keyword_relevance_from_server);
       if (keyword_verbatim_relevance > 0) {
         const base::string16& trimmed_verbatim =
             base::CollapseWhitespace(keyword_input_.text(), false);
         SearchSuggestionParser::SuggestResult verbatim(
-            trimmed_verbatim, AutocompleteMatchType::SEARCH_OTHER_ENGINE,
+            trimmed_verbatim, AutocompleteMatchType::SEARCH_OTHER_ENGINE, 0,
             trimmed_verbatim, base::string16(), base::string16(),
             base::string16(), base::string16(), nullptr, std::string(),
             std::string(), true, keyword_verbatim_relevance,
             keyword_relevance_from_server, false, trimmed_verbatim);
         AddMatchToMap(verbatim, std::string(),
                       did_not_accept_keyword_suggestion, false, true, &map);
       }
     }
   }
   AddRawHistoryResultsToMap(true, did_not_accept_keyword_suggestion, &map);
@@ skipping 165 matching lines @@
     // Add the match to |scored_results| by putting the what-you-typed match
     // on the front and appending all other matches.  We want the what-you-
     // typed match to always be first.
     SearchSuggestionParser::SuggestResults::iterator insertion_position =
         scored_results.end();
     if (trimmed_suggestion == trimmed_input) {
       found_what_you_typed_match = true;
       insertion_position = scored_results.begin();
     }
     SearchSuggestionParser::SuggestResult history_suggestion(
-        trimmed_suggestion, AutocompleteMatchType::SEARCH_HISTORY,
+        trimmed_suggestion, AutocompleteMatchType::SEARCH_HISTORY, 0,
         trimmed_suggestion, base::string16(), base::string16(),
         base::string16(), base::string16(), nullptr, std::string(),
         std::string(), is_keyword, relevance, false, false, trimmed_input);
     // History results are synchronous; they are received on the last keystroke.
     history_suggestion.set_received_after_last_keystroke(false);
     scored_results.insert(insertion_position, history_suggestion);
   }
 
   // History returns results sorted for us.  However, we may have docked some
   // results' scores, so things are no longer in order.  While keeping the
@@ skipping 221 matching lines @@
 AutocompleteMatch SearchProvider::NavigationToMatch(
     const SearchSuggestionParser::NavigationResult& navigation) {
   base::string16 input;
   const bool trimmed_whitespace = base::TrimWhitespace(
       navigation.from_keyword_provider() ?
           keyword_input_.text() : input_.text(),
       base::TRIM_TRAILING, &input) != base::TRIM_NONE;
   AutocompleteMatch match(this, navigation.relevance(), false,
                           navigation.type());
   match.destination_url = navigation.url();
+  match.subtype_identifier = navigation.subtype_identifier();
   BaseSearchProvider::SetDeletionURL(navigation.deletion_url(), &match);
   // First look for the user's input inside the formatted url as it would be
   // without trimming the scheme, so we can find matches at the beginning of the
   // scheme.
   const URLPrefix* prefix =
       URLPrefix::BestURLPrefix(navigation.formatted_url(), input);
   size_t match_start = (prefix == NULL) ?
       navigation.formatted_url().find(input) : prefix->prefix.length();
   bool trim_http = !AutocompleteInput::HasHTTPScheme(input) &&
       (!prefix || (match_start != 0));
@@ skipping 88 matching lines @@
   for (MatchMap::const_iterator i(map.begin()); i != map.end(); ++i)
     matches.push_back(i->second);
   std::sort(matches.begin(), matches.end(), &AutocompleteMatch::MoreRelevant);
 
   // If there is a top scoring entry, find the corresponding answer.
   if (!matches.empty())
     return answers_cache_.GetTopAnswerEntry(matches[0].contents);
 
   return AnswersQueryData();
 }