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>
 
 #include "base/i18n/icu_string_conversions.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/omnibox/browser/autocomplete_i18n.h"
 #include "components/omnibox/browser/autocomplete_input.h"
+#include "components/omnibox/browser/omnibox_field_trial.h"

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

Why do you need this?

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

Removed.

 #include "components/omnibox/browser/url_prefix.h"
 #include "components/url_formatter/url_fixer.h"
 #include "components/url_formatter/url_formatter.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "url/url_constants.h"
 
 namespace {
 
 AutocompleteMatchType::Type GetAutocompleteMatchType(const std::string& type) {
@@ skipping 189 matching lines @@
 
 SearchSuggestionParser::NavigationResult::NavigationResult(
     const AutocompleteSchemeClassifier& scheme_classifier,
     const GURL& url,
     AutocompleteMatchType::Type type,
     const base::string16& description,
     const std::string& deletion_url,
     bool from_keyword_provider,
     int relevance,
     bool relevance_from_server,
-    const base::string16& input_text)
+    const base::string16& input_text,
+    int specific_type_identifier)
     : Result(from_keyword_provider,
              relevance,
              relevance_from_server,
              type,
              deletion_url),
       url_(url),
       formatted_url_(AutocompleteInput::FormattedStringWithEquivalentMeaning(
           url,
           url_formatter::FormatUrl(url,
                                    url_formatter::kFormatUrlOmitAll &
                                        ~url_formatter::kFormatUrlOmitHTTP,
                                    net::UnescapeRule::SPACES,
                                    nullptr,
                                    nullptr,
                                    nullptr),
           scheme_classifier)),
-      description_(description) {
+      description_(description),
+      specific_type_identifier_(specific_type_identifier) {
   DCHECK(url_.is_valid());
   CalculateAndClassifyMatchContents(true, input_text);
 }
 
+SearchSuggestionParser::NavigationResult::NavigationResult(
+    const NavigationResult& nav) = default;
 SearchSuggestionParser::NavigationResult::~NavigationResult() {}
 
 void
 SearchSuggestionParser::NavigationResult::CalculateAndClassifyMatchContents(
     const bool allow_bolding_nothing,
     const base::string16& input_text) {
   if (input_text.empty()) {
     // In case of zero-suggest results, do not highlight matches.
     match_contents_class_.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
@@ skipping 144 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("specifictypeid", &specific_type_identifiers) &&

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

Let's use the "google:" as with everything else here.

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

Done.

+        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();
@@ skipping 25 matching lines @@
 
     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);
+        // add zero suggest subtype

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

Correct comment (not just zero suggest; we're not calling them subtypes in the
code; plus make into a sentence.)

Also, per my request to make this more general, it shouldn't be in this block
limited to navsuggestions.

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

I removed it, as the code is self explanatory.

+        int specific_type_identifier = 0;
+        if (specific_type_identifiers) {
+          specific_type_identifiers->GetInteger(index,
+                                                &specific_type_identifier);
+        }
         results->navigation_results.push_back(NavigationResult(
             scheme_classifier, url, match_type, title, deletion_url,
-            is_keyword_result, relevance, relevances != NULL, input.text()));
+            is_keyword_result, relevance, relevances != NULL, input.text(),
+            specific_type_identifier));
       }
     } 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 47 matching lines @@
           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;
 }