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

chrome/browser/autocomplete/search_provider_unittest.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 <string>
 
@@ skipping 2489 matching lines @@
   {
     // Reset the session and check that bits are reset.
     provider_->ResetSession();
     ProvidersInfo providers_info;
     provider_->AddProviderInfo(&providers_info);
     ASSERT_EQ(1U, providers_info.size());
     EXPECT_EQ(0, providers_info[0].field_trial_triggered_size());
     EXPECT_EQ(0, providers_info[0].field_trial_triggered_in_session_size());
   }
 }
+// A basic test that verifies the specific type identifier parsing logic.
+TEST_F(SearchProviderTest, SpecificTypeIdentifierParsing) {
+  struct Match {
+    std::string contents;
+    int specific_type_identifier;
+  };
+
+  struct {
+    const std::string input_text;
+    const std::string provider_response_json;
+    const Match matches[2];

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

nit: expected_matches

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

Done.

+  } cases[] = {
+      {// Check that the specific type is set to 0 when these values are not

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

Note to self: I'm not reviewing the rest of this test given my comment on the
parser.

+       // proviede in the response.
+       "a",
+       "[\"a\",[\"ab\",\"http://b.com\"],[],[], "
+       "{\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\"]}]",
+       {{"ab", 0}, {"b.com", 0}}},
+      {// Check that the specific type works for zero-suggest suggestions.
+       "c",
+       "[\"c\",[\"cd\",\"http://d.com\"],[],[], "
+       "{\"google:suggesttype\":[\"QUERY\", "
+       "\"NAVIGATION\"],\"google:specifictypeid\":[1, 3]}]",
+       {{"cd", 1}, {"d.com", 3}}},
+      {// Check that the specific type is set to zero when the number of
+       // suggestions is smaller than the number of typeid's provided.
+       "foo",
+       "[\"foo\",[\"foo bar\", \"foo baz\"],[],[], "
+       "{\"google:suggesttype\":[\"QUERY\"],\"google:specifictypeid\":[1, 2, "
+       "3]}]",
+       {{"foo bar", 0}, {"foo baz", 0}}},
+      {// Check that the specific type is set to zero when the number of
+       // suggestions is largerthan the number of typeid's provided.
+       "bar",
+       "[\"bar\",[\"bar foo\", \"bar foz\"],[],[], "
+       "{\"google:suggesttype\":[\"QUERY\"],\"google:specifictypeid\":[1]}]",
+       {{"bar foo", 0}, {"bar foz", 0}}}};
+
+  for (size_t i = 0; i < arraysize(cases); ++i) {
+    QueryForInputAndWaitForFetcherResponses(
+        ASCIIToUTF16(cases[i].input_text), false,
+        cases[i].provider_response_json, std::string());
+
+    // Check for the match and field trial triggered bits.
+    const ACMatches& matches = provider_->matches();
+    ASSERT_FALSE(matches.empty());
+    for (size_t j = 0; j < arraysize(cases[i].matches); ++j) {
+      if (cases[i].matches[j].contents == kNotApplicable)
+        continue;
+      AutocompleteMatch match;
+      EXPECT_TRUE(FindMatchWithContents(
+          ASCIIToUTF16(cases[i].matches[j].contents), &match));
+      EXPECT_EQ(cases[i].matches[j].specific_type_identifier,
+                match.specific_type_identifier);
+    }
+  }
+}
 
 // Verifies inline autocompletion of navigational results.
 TEST_F(SearchProviderTest, NavigationInline) {
   struct {
     const std::string input;
     const std::string url;
     // Test the expected fill_into_edit, which may drop "http://".
     // Some cases do not trim "http://" to match from the start of the scheme.
     const std::string fill_into_edit;
     const std::string inline_autocompletion;
@@ skipping 140 matching lines @@
                      "https://abc.com/path/file.htm?q=x#foo",
                                "c.com/path/file.htm?q=x#foo",     true, false },
 
   };
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     // First test regular mode.
     QueryForInput(ASCIIToUTF16(cases[i].input), false, false);
     SearchSuggestionParser::NavigationResult result(
         ChromeAutocompleteSchemeClassifier(&profile_), GURL(cases[i].url),
-        AutocompleteMatchType::NAVSUGGEST, base::string16(), std::string(),
+        AutocompleteMatchType::NAVSUGGEST, 0, base::string16(), std::string(),
         false, 0, false, ASCIIToUTF16(cases[i].input));
     result.set_received_after_last_keystroke(false);
     AutocompleteMatch match(provider_->NavigationToMatch(result));
     EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
               match.inline_autocompletion);
     EXPECT_EQ(ASCIIToUTF16(cases[i].fill_into_edit), match.fill_into_edit);
     EXPECT_EQ(cases[i].allowed_to_be_default_match_in_regular_mode,
               match.allowed_to_be_default_match);
 
     // Then test prevent-inline-autocomplete mode.
     QueryForInput(ASCIIToUTF16(cases[i].input), true, false);
     SearchSuggestionParser::NavigationResult result_prevent_inline(
         ChromeAutocompleteSchemeClassifier(&profile_), GURL(cases[i].url),
-        AutocompleteMatchType::NAVSUGGEST, base::string16(), std::string(),
+        AutocompleteMatchType::NAVSUGGEST, 0, base::string16(), std::string(),
         false, 0, false, ASCIIToUTF16(cases[i].input));
     result_prevent_inline.set_received_after_last_keystroke(false);
     AutocompleteMatch match_prevent_inline(
         provider_->NavigationToMatch(result_prevent_inline));
     EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
               match_prevent_inline.inline_autocompletion);
     EXPECT_EQ(ASCIIToUTF16(cases[i].fill_into_edit),
               match_prevent_inline.fill_into_edit);
     EXPECT_EQ(cases[i].allowed_to_be_default_match_in_prevent_inline_mode,
               match_prevent_inline.allowed_to_be_default_match);
   }
 }
 
 // Verifies that "http://" is not trimmed for input that is a leading substring.
 TEST_F(SearchProviderTest, NavigationInlineSchemeSubstring) {
   const base::string16 input(ASCIIToUTF16("ht"));
   const base::string16 url(ASCIIToUTF16("http://a.com"));
   SearchSuggestionParser::NavigationResult result(
       ChromeAutocompleteSchemeClassifier(&profile_), GURL(url),
-      AutocompleteMatchType::NAVSUGGEST,
-      base::string16(), std::string(), false, 0, false, input);
+      AutocompleteMatchType::NAVSUGGEST, 0, base::string16(), std::string(),
+      false, 0, false, input);
   result.set_received_after_last_keystroke(false);
 
   // Check the offset and strings when inline autocompletion is allowed.
   QueryForInput(input, false, false);
   AutocompleteMatch match_inline(provider_->NavigationToMatch(result));
   EXPECT_EQ(url, match_inline.fill_into_edit);
   EXPECT_EQ(url.substr(2), match_inline.inline_autocompletion);
   EXPECT_TRUE(match_inline.allowed_to_be_default_match);
   EXPECT_EQ(url, match_inline.contents);
 
   // Check the same strings when inline autocompletion is prevented.
   QueryForInput(input, true, false);
   AutocompleteMatch match_prevent(provider_->NavigationToMatch(result));
   EXPECT_EQ(url, match_prevent.fill_into_edit);
   EXPECT_FALSE(match_prevent.allowed_to_be_default_match);
   EXPECT_EQ(url, match_prevent.contents);
 }
 
 // Verifies that input "w" marks a more significant domain label than "www.".
 TEST_F(SearchProviderTest, NavigationInlineDomainClassify) {
   QueryForInput(ASCIIToUTF16("w"), false, false);
   SearchSuggestionParser::NavigationResult result(
-      ChromeAutocompleteSchemeClassifier(&profile_),
-      GURL("http://www.wow.com"), AutocompleteMatchType::NAVSUGGEST,
-      base::string16(), std::string(), false, 0, false, ASCIIToUTF16("w"));
+      ChromeAutocompleteSchemeClassifier(&profile_), GURL("http://www.wow.com"),
+      AutocompleteMatchType::NAVSUGGEST, 0, base::string16(), std::string(),
+      false, 0, false, ASCIIToUTF16("w"));
   result.set_received_after_last_keystroke(false);
   AutocompleteMatch match(provider_->NavigationToMatch(result));
   EXPECT_EQ(ASCIIToUTF16("ow.com"), match.inline_autocompletion);
   EXPECT_TRUE(match.allowed_to_be_default_match);
   EXPECT_EQ(ASCIIToUTF16("www.wow.com"), match.fill_into_edit);
   EXPECT_EQ(ASCIIToUTF16("www.wow.com"), match.contents);
 
   // Ensure that the match for input "w" is marked on "wow" and not "www".
   ASSERT_EQ(3U, match.contents_class.size());
   EXPECT_EQ(0U, match.contents_class[0].offset);
@@ skipping 109 matching lines @@
                               AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
                               false };
 
   struct {
     const std::string input_text;
     bool prefer_keyword_provider_results;
     const std::string default_provider_response_json;
     const std::string keyword_provider_response_json;
     const Match matches[5];
   } cases[] = {
-    // Default provider response does not have prefetch details. Ensure that the
-    // suggestions are not marked as prefetch query.
-    { "a",
-      false,
-      "[\"a\",[\"b\", \"c\"],[],[],{\"google:suggestrelevance\":[1, 2]}]",
-      std::string(),
-      { { "a", false, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, false },
-        { "c", false, AutocompleteMatchType::SEARCH_SUGGEST, false },
-        { "b", false, AutocompleteMatchType::SEARCH_SUGGEST, false },
-        kEmptyMatch,
-        kEmptyMatch
+      // Default provider response does not have prefetch details. Ensure that
+      // the suggestions are not marked as prefetch query.
+      {
+          "a",
+          false,
+          "[\"a\",[\"b\", \"c\"],[],[],{\"google:suggestrelevance\":[1, 2]}]",
+          std::string(),
+          {{"a", false, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, false},
+           {"c", false, AutocompleteMatchType::SEARCH_SUGGEST, false},
+           {"b", false, AutocompleteMatchType::SEARCH_SUGGEST, false},
+           kEmptyMatch,
+           kEmptyMatch},
       },
-    },
-    // Ensure that default provider suggest response prefetch details are
-    // parsed and recorded in AutocompleteMatch.
-    { "ab",
-      false,
-      "[\"ab\",[\"abc\", \"http://b.com\", \"http://c.com\"],[],[],"
+      // Ensure that default provider suggest response prefetch details are
+      // parsed and recorded in AutocompleteMatch.
+      {
+          "ab",
+          false,
+          "[\"ab\",[\"abc\", \"http://b.com\", \"http://c.com\"],[],[],"
           "{\"google:clientdata\":{\"phi\": 0},"
           "\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\", \"NAVIGATION\"],"
           "\"google:suggestrelevance\":[999, 12, 1]}]",
-      std::string(),
-      { { "ab",    false, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, false },
-        { "abc",   true,  AutocompleteMatchType::SEARCH_SUGGEST, false },
-        { "b.com", false, AutocompleteMatchType::NAVSUGGEST, false },
-        { "c.com", false, AutocompleteMatchType::NAVSUGGEST, false },
-        kEmptyMatch
+          std::string(),
+          {{"ab", false, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, false},
+           {"abc", true, AutocompleteMatchType::SEARCH_SUGGEST, false},
+           {"b.com", false, AutocompleteMatchType::NAVSUGGEST, false},
+           {"c.com", false, AutocompleteMatchType::NAVSUGGEST, false},
+           kEmptyMatch},
       },
-    },
-    // Default provider suggest response has prefetch details.
-    // SEARCH_WHAT_YOU_TYPE suggestion outranks SEARCH_SUGGEST suggestion for
-    // the same query string. Ensure that the prefetch details from
-    // SEARCH_SUGGEST match are set onto SEARCH_WHAT_YOU_TYPE match.
-    { "ab",
-      false,
-      "[\"ab\",[\"ab\", \"http://ab.com\"],[],[],"
+      // Default provider suggest response has prefetch details.
+      // SEARCH_WHAT_YOU_TYPE suggestion outranks SEARCH_SUGGEST suggestion for
+      // the same query string. Ensure that the prefetch details from
+      // SEARCH_SUGGEST match are set onto SEARCH_WHAT_YOU_TYPE match.
+      {
+          "ab",
+          false,
+          "[\"ab\",[\"ab\", \"http://ab.com\"],[],[],"
           "{\"google:clientdata\":{\"phi\": 0},"
           "\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\"],"
           "\"google:suggestrelevance\":[99, 98]}]",
-      std::string(),
-      { {"ab", true, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, false },
-        {"ab.com", false, AutocompleteMatchType::NAVSUGGEST, false },
-        kEmptyMatch,
-        kEmptyMatch,
-        kEmptyMatch
+          std::string(),
+          {{"ab", true, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, false},
+           {"ab.com", false, AutocompleteMatchType::NAVSUGGEST, false},
+           kEmptyMatch,
+           kEmptyMatch,
+           kEmptyMatch},
       },
-    },
-    // Default provider response has prefetch details. We prefer keyword
-    // provider results. Ensure that prefetch bit for a suggestion from the
-    // default search provider does not get copied onto a higher-scoring match
-    // for the same query string from the keyword provider.
-    { "k a",
-      true,
-      "[\"k a\",[\"a\", \"ab\"],[],[], {\"google:clientdata\":{\"phi\": 0},"
+      // Default provider response has prefetch details. We prefer keyword
+      // provider results. Ensure that prefetch bit for a suggestion from the
+      // default search provider does not get copied onto a higher-scoring match
+      // for the same query string from the keyword provider.
+      {
+          "k a",
+          true,
+          "[\"k a\",[\"a\", \"ab\"],[],[], {\"google:clientdata\":{\"phi\": 0},"
           "\"google:suggesttype\":[\"QUERY\", \"QUERY\"],"
           "\"google:suggestrelevance\":[9, 12]}]",
-      "[\"a\",[\"b\", \"c\"],[],[],{\"google:suggestrelevance\":[1, 2]}]",
-      { { "a", false, AutocompleteMatchType::SEARCH_OTHER_ENGINE, true},
-        { "k a", false, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, false },
-        { "ab", false, AutocompleteMatchType::SEARCH_SUGGEST, false },
-        { "c", false, AutocompleteMatchType::SEARCH_SUGGEST, true },
-        { "b", false, AutocompleteMatchType::SEARCH_SUGGEST, true }
-      },
-    }
-  };
+          "[\"a\",[\"b\", \"c\"],[],[],{\"google:suggestrelevance\":[1, 2]}]",
+          {{"a", false, AutocompleteMatchType::SEARCH_OTHER_ENGINE, true},
+           {"k a", false, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, false},
+           {"ab", false, AutocompleteMatchType::SEARCH_SUGGEST, false},
+           {"c", false, AutocompleteMatchType::SEARCH_SUGGEST, true},
+           {"b", false, AutocompleteMatchType::SEARCH_SUGGEST, true}},
+      }};
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     QueryForInputAndWaitForFetcherResponses(
         ASCIIToUTF16(cases[i].input_text),
         cases[i].prefer_keyword_provider_results,
         cases[i].default_provider_response_json,
         cases[i].prefer_keyword_provider_results ?
             cases[i].keyword_provider_response_json : std::string());
 
     const std::string description =
@@ skipping 532 matching lines @@
   ASSERT_FALSE(provider_->answers_cache_.empty());
 
   // Without scored results, no answers will be retrieved.
   AnswersQueryData answer = provider_->FindAnswersPrefetchData();
   EXPECT_TRUE(answer.full_query_text.empty());
   EXPECT_TRUE(answer.query_type.empty());
 
   // Inject a scored result, which will trigger answer retrieval.
   base::string16 query = base::ASCIIToUTF16("weather los angeles");
   SearchSuggestionParser::SuggestResult suggest_result(
-      query, AutocompleteMatchType::SEARCH_HISTORY, query, base::string16(),
+      query, AutocompleteMatchType::SEARCH_HISTORY, 0, query, base::string16(),
       base::string16(), base::string16(), base::string16(), nullptr,
       std::string(), std::string(), false, 1200, false, false, query);
   QueryForInput(ASCIIToUTF16("weather l"), false, false);
   provider_->transformed_default_history_results_.push_back(suggest_result);
   answer = provider_->FindAnswersPrefetchData();
   EXPECT_EQ(base::ASCIIToUTF16("weather los angeles"), answer.full_query_text);
   EXPECT_EQ(base::ASCIIToUTF16("2334"), answer.query_type);
 }
 
 TEST_F(SearchProviderTest, RemoveExtraAnswers) {
@@ skipping 78 matching lines @@
   EXPECT_TRUE(fetcher);
   // Even if the fetcher returns results, we should still have no suggestions
   // (though the provider should now be done).
   fetcher->set_response_code(200);
   fetcher->SetResponseString(R"(["",["a", "b"],[],[],{}])");
   fetcher->delegate()->OnURLFetchComplete(fetcher);
   RunTillProviderDone();
   EXPECT_TRUE(provider_->done());
   EXPECT_TRUE(provider_->matches().empty());
 }