Interpret '?' and Ctrl-K or Ctrl-E as putting omnibox in keyword search mode for Default Search Pro…

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 201 matching lines @@
       const base::string16& text,
       const bool prefer_keyword,
       const std::string& default_fetcher_response,
       const std::string& keyword_fetcher_response);
 
   // Notifies the URLFetcher for the suggest query corresponding to the default
   // search provider that it's done.
   // Be sure and wrap calls to this in ASSERT_NO_FATAL_FAILURE.
   void FinishDefaultSuggestQuery();
 
-  // Runs SearchProvider on |input|, for which the suggest server replies
-  // with |json|, and expects that the resulting matches' contents equals
-  // that in |matches|.  An empty entry in |matches| means no match should
-  // be returned in that position.  Reports any errors with a message that
-  // includes |error_description|.
-  void ForcedQueryTestHelper(const std::string& input,
-                             const std::string& json,
-                             const std::string matches[3],
-                             const std::string& error_description);
-
   // Verifies that |matches| and |expected_matches| agree on the first
   // |num_expected_matches|, displaying an error message that includes
   // |description| for any disagreement.
   void CheckMatches(const std::string& description,
                     const size_t num_expected_matches,
                     const ExpectedMatch expected_matches[],
                     const ACMatches& matches);
 
   void ResetFieldTrialList();
 
@@ skipping 243 matching lines @@
   net::TestURLFetcher* default_fetcher =
       test_factory_.GetFetcherByID(
           SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(default_fetcher);
 
   // Tell the SearchProvider the default suggest query is done.
   default_fetcher->set_response_code(200);
   default_fetcher->delegate()->OnURLFetchComplete(default_fetcher);
 }
 
-void SearchProviderTest::ForcedQueryTestHelper(
-    const std::string& input,
-    const std::string& json,
-    const std::string expected_matches[3],
-    const std::string& error_description) {
-  // Send the query twice in order to have a synchronous pass after the first
-  // response is received.  This is necessary because SearchProvider doesn't
-  // allow an asynchronous response to change the default match.
-  for (size_t i = 0; i < 2; ++i) {
-    QueryForInputAndWaitForFetcherResponses(
-        ASCIIToUTF16(input), false, json, std::string());
-  }
-
-  const ACMatches& matches = provider_->matches();
-  ASSERT_LE(matches.size(), 3u);
-  size_t i = 0;
-  // Ensure that the returned matches equal the expectations.
-  for (; i < matches.size(); ++i) {
-    EXPECT_EQ(ASCIIToUTF16(expected_matches[i]), matches[i].contents) <<
-        error_description;
-  }
-  // Ensure that no expected matches are missing.
-  for (; i < 3u; ++i) {
-    EXPECT_EQ(std::string(), expected_matches[i]) <<
-        "Case #" << i << ": " << error_description;
-  }
-}
-
 void SearchProviderTest::CheckMatches(const std::string& description,
                                       const size_t num_expected_matches,
                                       const ExpectedMatch expected_matches[],
                                       const ACMatches& matches) {
   ASSERT_FALSE(matches.empty());
   ASSERT_LE(matches.size(), num_expected_matches);
   size_t i = 0;
   SCOPED_TRACE(description);
   // Ensure that the returned matches equal the expectations.
   for (; i < matches.size(); ++i) {
@@ skipping 267 matching lines @@
   // 'docs.google.com'. The search term should have a lower priority than the
   // what you typed match.
   ASSERT_EQ(2u, provider_->matches().size());
   AutocompleteMatch term_match;
   EXPECT_TRUE(FindMatchWithDestination(url, &term_match));
   EXPECT_GT(wyt_match.relevance, term_match.relevance);
   EXPECT_TRUE(wyt_match.allowed_to_be_default_match);
   EXPECT_TRUE(term_match.allowed_to_be_default_match);
 }
 
-TEST_F(SearchProviderTest, DontGiveNavsuggestionsInForcedQueryMode) {
-  const std::string kEmptyMatch;
-  struct {
-    const std::string json;
-    const std::string matches_in_default_mode[3];
-    const std::string matches_in_forced_query_mode[3];
-  } cases[] = {
-    // Without suggested relevance scores.
-    { "[\"a\",[\"http://a1.com\", \"a2\"],[],[],"
-       "{\"google:suggesttype\":[\"NAVIGATION\", \"QUERY\"]}]",
-      { "a", "a1.com", "a2" },
-      { "a", "a2", kEmptyMatch } },
-
-    // With suggested relevance scores in a situation where navsuggest would
-    // go second.
-    { "[\"a\",[\"http://a1.com\", \"a2\"],[],[],"
-       "{\"google:suggesttype\":[\"NAVIGATION\", \"QUERY\"],"
-        "\"google:suggestrelevance\":[1250, 1200]}]",
-      { "a", "a1.com", "a2" },
-      { "a", "a2", kEmptyMatch } },
-
-    // With suggested relevance scores in a situation where navsuggest
-    // would go first.
-    { "[\"a\",[\"http://a1.com\", \"a2\"],[],[],"
-       "{\"google:suggesttype\":[\"NAVIGATION\", \"QUERY\"],"
-        "\"google:suggestrelevance\":[1350, 1250]}]",
-      { "a1.com", "a", "a2" },
-      { "a", "a2", kEmptyMatch } },
-
-    // With suggested relevance scores in a situation where navsuggest
-    // would go first only because verbatim has been demoted.
-    { "[\"a\",[\"http://a1.com\", \"a2\"],[],[],"
-       "{\"google:suggesttype\":[\"NAVIGATION\", \"QUERY\"],"
-        "\"google:suggestrelevance\":[1450, 1400],"
-        "\"google:verbatimrelevance\":1350}]",
-      { "a1.com", "a2", "a" },
-      { "a2", "a", kEmptyMatch } },
-  };
-
-  for (size_t i = 0; i < arraysize(cases); ++i) {
-    ForcedQueryTestHelper("a", cases[i].json, cases[i].matches_in_default_mode,
-                           "regular input with json=" + cases[i].json);
-    ForcedQueryTestHelper("?a", cases[i].json,
-                          cases[i].matches_in_forced_query_mode,
-                          "forced query input with json=" + cases[i].json);
-  }
-}
-
 // A multiword search with one visit should not autocomplete until multiple
 // words are typed.
 TEST_F(SearchProviderTest, DontAutocompleteUntilMultipleWordsTyped) {
   GURL term_url(AddSearchToHistory(default_t_url_, ASCIIToUTF16("one search"),
                                    1));
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteMatch wyt_match;
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("on"),
                                                       &wyt_match));
@@ skipping 1857 matching lines @@
     { "www.ab",      "https://www.abc.com/path/file.htm?q=x#foo",
                      "https://www.abc.com/path/file.htm?q=x#foo",
                                    "c.com/path/file.htm?q=x#foo", true, false },
     { "ab",          "https://www.abc.com/path/file.htm?q=x#foo",
                      "https://www.abc.com/path/file.htm?q=x#foo",
                                    "c.com/path/file.htm?q=x#foo", true, false },
     { "ab",          "https://abc.com/path/file.htm?q=x#foo",
                      "https://abc.com/path/file.htm?q=x#foo",
                                "c.com/path/file.htm?q=x#foo",     true, false },
 
-    // Forced query input should inline and retain the "?" prefix.
-    { "?http://www.ab",  "http://www.abc.com",
-                        "?http://www.abc.com", "c.com",       true, false },
-    { "?www.ab",         "http://www.abc.com",
-                               "?www.abc.com", "c.com",       true, false },
-    { "?ab",             "http://www.abc.com",
-                               "?www.abc.com", "c.com",       true, false },
-    { "?abc.com",        "http://www.abc.com",
-                               "?www.abc.com", std::string(), true, true },
   };
 
   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(),
         false, 0, false, ASCIIToUTF16(cases[i].input), std::string());
     result.set_received_after_last_keystroke(false);
@@ skipping 844 matching lines @@
 }
 
 TEST_F(SearchProviderTest, DoesNotProvideOnFocus) {
   AutocompleteInput input(
       base::ASCIIToUTF16("f"), base::string16::npos, std::string(), GURL(),
       metrics::OmniboxEventProto::INVALID_SPEC, false, true, true, true, true,
       ChromeAutocompleteSchemeClassifier(&profile_));
   provider_->Start(input, false);
   EXPECT_TRUE(provider_->matches().empty());
 }