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

components/omnibox/browser/search_suggestion_parser.cc

 // Copyright 2014 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_suggestion_parser.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 37 matching lines @@
 }
 
 }  // namespace
 
 // SearchSuggestionParser::Result ----------------------------------------------
 
 SearchSuggestionParser::Result::Result(bool from_keyword_provider,
                                        int relevance,
                                        bool relevance_from_server,
                                        AutocompleteMatchType::Type type,
+                                       int specific_type_identifier,
                                        const std::string& deletion_url)
     : from_keyword_provider_(from_keyword_provider),
       type_(type),
+      specific_type_identifier_(specific_type_identifier),
       relevance_(relevance),
       relevance_from_server_(relevance_from_server),
       received_after_last_keystroke_(true),
       deletion_url_(deletion_url) {}
 
 SearchSuggestionParser::Result::Result(const Result& other) = default;
 
 SearchSuggestionParser::Result::~Result() {}
 
 // SearchSuggestionParser::SuggestResult ---------------------------------------
 
 SearchSuggestionParser::SuggestResult::SuggestResult(
     const base::string16& suggestion,
     AutocompleteMatchType::Type type,
+    int specific_type_identifier,
     const base::string16& match_contents,
     const base::string16& match_contents_prefix,
     const base::string16& annotation,
     const base::string16& answer_contents,
     const base::string16& answer_type,
     std::unique_ptr<SuggestionAnswer> answer,
     const std::string& suggest_query_params,
     const std::string& deletion_url,
     bool from_keyword_provider,
     int relevance,
     bool relevance_from_server,
     bool should_prefetch,
     const base::string16& input_text)
     : Result(from_keyword_provider,
              relevance,
              relevance_from_server,
              type,
+             specific_type_identifier,
              deletion_url),
       suggestion_(suggestion),
       match_contents_prefix_(match_contents_prefix),
       annotation_(annotation),
       suggest_query_params_(suggest_query_params),
       answer_contents_(answer_contents),
       answer_type_(answer_type),
       answer_(std::move(answer)),
       should_prefetch_(should_prefetch) {
   match_contents_ = match_contents;
@@ skipping 115 matching lines @@
     return 100;
   return ((input.type() == metrics::OmniboxInputType::URL) ? 300 : 600);
 }
 
 // SearchSuggestionParser::NavigationResult ------------------------------------
 
 SearchSuggestionParser::NavigationResult::NavigationResult(
     const AutocompleteSchemeClassifier& scheme_classifier,
     const GURL& url,
     AutocompleteMatchType::Type type,
+    int specific_type_identifier,
     const base::string16& description,
     const std::string& deletion_url,
     bool from_keyword_provider,
     int relevance,
     bool relevance_from_server,
     const base::string16& input_text)
     : Result(from_keyword_provider,
              relevance,
              relevance_from_server,
              type,
+             specific_type_identifier,
              deletion_url),
       url_(url),
       formatted_url_(AutocompleteInput::FormattedStringWithEquivalentMeaning(
           url,
           url_formatter::FormatUrl(url,
                                    url_formatter::kFormatUrlOmitAll &
                                        ~url_formatter::kFormatUrlOmitHTTP,
                                    net::UnescapeRule::SPACES,
                                    nullptr,
                                    nullptr,
@@ skipping 161 matching lines @@
 
   // 4th element: Disregard the query URL list for now.
 
   // Reset suggested relevance information.
   results->verbatim_relevance = -1;
 
   // 5th element: Optional key-value pairs from the Suggest server.
   const base::ListValue* types = NULL;
   const base::ListValue* relevances = NULL;
   const base::ListValue* suggestion_details = NULL;
+  const base::ListValue* specific_type_identifiers = NULL;
   const base::DictionaryValue* extras = NULL;
   int prefetch_index = -1;
   if (root_list->GetDictionary(4, &extras)) {
     extras->GetList("google:suggesttype", &types);
 
     // Discard this list if its size does not match that of the suggestions.
     if (extras->GetList("google:suggestrelevance", &relevances) &&
         (relevances->GetSize() != results_list->GetSize()))
       relevances = NULL;
     extras->GetInteger("google:verbatimrelevance",
                        &results->verbatim_relevance);
 
     // Check if the active suggest field trial (if any) has triggered either
     // for the default provider or keyword provider.
     results->field_trial_triggered = false;
     extras->GetBoolean("google:fieldtrialtriggered",
                        &results->field_trial_triggered);
 
     const base::DictionaryValue* client_data = NULL;
     if (extras->GetDictionary("google:clientdata", &client_data) && client_data)
       client_data->GetInteger("phi", &prefetch_index);
 
     if (extras->GetList("google:suggestdetail", &suggestion_details) &&
         suggestion_details->GetSize() != results_list->GetSize())
       suggestion_details = NULL;
 
+    // Get specific type identifiers.
+    if (extras->GetList("google:specifictypeid", &specific_type_identifiers) &&

[Mark P, 2017/03/23 22:49:54]

I think it'd be more appropriate to have these identified in the
"google:suggestdetail" array, not as a separate parallel array.

[gcomanici, 2017/03/24 16:24:59]

Are you sure? google:suggestdetail is a dictionary, so really all I would change
is add the separate  array inside google:suggestdetail and add another layer.
IMO we don't really gain much. 

[Mark P, 2017/03/25 22:16:48]

You're right; I was wrong.  I misread the sample strings in your test file and
thought it was structured differently.  The way you chose to structure it is
good.

+        specific_type_identifiers->GetSize() != results_list->GetSize()) {
+      specific_type_identifiers = NULL;
+    }
+
     // Store the metadata that came with the response in case we need to pass it
     // along with the prefetch query to Instant.
     JSONStringValueSerializer json_serializer(&results->metadata);
     json_serializer.Serialize(*extras);
   }
 
   // Clear the previous results now that new results are available.
   results->suggest_results.clear();
   results->navigation_results.clear();
   results->answers_image_urls.clear();
 
   base::string16 suggestion;
   std::string type;
   int relevance = default_result_relevance;
   const base::string16& trimmed_input =
       base::CollapseWhitespace(input.text(), false);
   for (size_t index = 0; results_list->GetString(index, &suggestion); ++index) {
     // Google search may return empty suggestions for weird input characters,
     // they make no sense at all and can cause problems in our code.
     if (suggestion.empty())
       continue;
 
     // Apply valid suggested relevance scores; discard invalid lists.
     if (relevances != NULL && !relevances->GetInteger(index, &relevance))
       relevances = NULL;
     AutocompleteMatchType::Type match_type =
         AutocompleteMatchType::SEARCH_SUGGEST;
+    int specific_type_identifier = 0;
+    if (specific_type_identifiers) {
+      specific_type_identifiers->GetInteger(index, &specific_type_identifier);
+    }
     if (types && types->GetString(index, &type))
       match_type = GetAutocompleteMatchType(type);
     const base::DictionaryValue* suggestion_detail = NULL;
     std::string deletion_url;
 
     if (suggestion_details &&
         suggestion_details->GetDictionary(index, &suggestion_detail))
       suggestion_detail->GetString("du", &deletion_url);
 
     if ((match_type == AutocompleteMatchType::NAVSUGGEST) ||
         (match_type == AutocompleteMatchType::NAVSUGGEST_PERSONALIZED)) {
       // Do not blindly trust the URL coming from the server to be valid.
       GURL url(url_formatter::FixupURL(base::UTF16ToUTF8(suggestion),
                                        std::string()));
       if (url.is_valid()) {
         base::string16 title;
         if (descriptions != NULL)
           descriptions->GetString(index, &title);
         results->navigation_results.push_back(NavigationResult(
-            scheme_classifier, url, match_type, title, deletion_url,
-            is_keyword_result, relevance, relevances != NULL, input.text()));
+            scheme_classifier, url, match_type, specific_type_identifier, title,
+            deletion_url, is_keyword_result, relevance, relevances != NULL,
+            input.text()));
       }
     } else {
       // TODO(dschuyler) If the "= " is no longer sent from the back-end
       // then this may be removed.
       if ((match_type == AutocompleteMatchType::CALCULATOR) &&
           !suggestion.compare(0, 2, base::UTF8ToUTF16("= ")))
         suggestion.erase(0, 2);
 
       base::string16 match_contents = suggestion;
       base::string16 match_contents_prefix;
@@ skipping 37 matching lines @@
             }
             UMA_HISTOGRAM_BOOLEAN("Omnibox.AnswerParseSuccess",
                                   answer_parsed_successfully);
           }
         }
       }
 
       bool should_prefetch = static_cast<int>(index) == prefetch_index;
       results->suggest_results.push_back(SuggestResult(
           base::CollapseWhitespace(suggestion, false), match_type,
+          specific_type_identifier,
           base::CollapseWhitespace(match_contents, false),
           match_contents_prefix, annotation, answer_contents, answer_type_str,
           std::move(answer), suggest_query_params, deletion_url,
           is_keyword_result, relevance, relevances != NULL, should_prefetch,
           trimmed_input));
     }
   }
   results->relevances_from_server = relevances != NULL;
   return true;
 }