Omnibox: Don't Let Users Escape Keyword Mode Accidentally

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 "chrome/browser/autocomplete/search_provider.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
@@ skipping 43 matching lines @@
 //   TemplateURL has a valid suggest and search URL.
 // . The URL created by using the search term term1_ with default_t_url_ is
 //   added to history.
 // . The URL created by using the search term keyword_term_ with keyword_t_url_
 //   is added to history.
 // . test_factory_ is set as the URLFetcherFactory.
 class SearchProviderTest : public testing::Test,
                            public AutocompleteProviderListener {
  public:
   struct ResultInfo {
-    ResultInfo() : result_type(AutocompleteMatchType::NUM_TYPES) {
+    ResultInfo() : result_type(AutocompleteMatchType::NUM_TYPES),
+                   allowed_to_be_default_match(false) {
     }
     ResultInfo(GURL gurl,
                AutocompleteMatch::Type result_type,
+               bool allowed_to_be_default_match,
                string16 fill_into_edit)
       : gurl(gurl),
         result_type(result_type),
+        allowed_to_be_default_match(allowed_to_be_default_match),
         fill_into_edit(fill_into_edit) {
     }
 
     const GURL gurl;
     const AutocompleteMatch::Type result_type;
+    const bool allowed_to_be_default_match;
     const string16 fill_into_edit;
   };
 
   struct TestData {
     const string16 input;
     const size_t num_results;
     const ResultInfo output[3];
   };
 
   SearchProviderTest()
@@ skipping 172 matching lines @@
         (prefer_keyword ? ASCIIToUTF16("true") : ASCIIToUTF16("false"));
     EXPECT_EQ(cases[i].num_results, matches.size()) << diagnostic_details;
     if (matches.size() == cases[i].num_results) {
       for (size_t j = 0; j < cases[i].num_results; ++j) {
         EXPECT_EQ(cases[i].output[j].gurl, matches[j].destination_url) <<
             diagnostic_details;
         EXPECT_EQ(cases[i].output[j].result_type, matches[j].type) <<
             diagnostic_details;
         EXPECT_EQ(cases[i].output[j].fill_into_edit,
                   matches[j].fill_into_edit) <<
             diagnostic_details;

[msw, 2013/11/20 21:05:03]

nit: this fits on the line above.

[Mark P, 2013/11/21 21:30:22]

Done.

-        // All callers that use this helper function at the moment produce
-        // matches that are always allowed to be the default match.
-        EXPECT_TRUE(matches[j].allowed_to_be_default_match);
+        EXPECT_EQ(cases[i].output[j].allowed_to_be_default_match,
+                  matches[j].allowed_to_be_default_match) << diagnostic_details;
       }
     }
   }
 }
 
 void SearchProviderTest::OnProviderUpdate(bool updated_matches) {
   if (run_loop_ && provider_->done()) {
     run_loop_->Quit();
     run_loop_ = NULL;
   }
@@ skipping 544 matching lines @@
   ASSERT_EQ(3u, result.size());
   EXPECT_EQ(AutocompleteMatchType::SEARCH_HISTORY, result.match_at(0).type);
   EXPECT_EQ(AutocompleteMatchType::SEARCH_OTHER_ENGINE,
             result.match_at(1).type);
   EXPECT_EQ(AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
             result.match_at(2).type);
   EXPECT_GT(result.match_at(0).relevance, result.match_at(1).relevance);
   EXPECT_GT(result.match_at(1).relevance, result.match_at(2).relevance);
   EXPECT_TRUE(result.match_at(0).allowed_to_be_default_match);
   EXPECT_TRUE(result.match_at(1).allowed_to_be_default_match);
-  EXPECT_TRUE(result.match_at(2).allowed_to_be_default_match);
+  EXPECT_FALSE(result.match_at(2).allowed_to_be_default_match);
 
   // The two keyword results should come with the keyword we expect.
   EXPECT_EQ(ASCIIToUTF16("k"), result.match_at(0).keyword);
   EXPECT_EQ(ASCIIToUTF16("k"), result.match_at(1).keyword);
   // The default provider has a different keyword.  (We don't explicitly
   // set it during this test, so all we do is assert that it's different.)
   EXPECT_NE(result.match_at(0).keyword, result.match_at(2).keyword);
 
   // The top result will always have a description.  The third result,
   // coming from a different provider than the first two, should also.
   // Whether the second result has one doesn't matter much.  (If it was
   // missing, people would infer that it's the same search provider as
   // the one above it.)
   EXPECT_FALSE(result.match_at(0).description.empty());
   EXPECT_FALSE(result.match_at(2).description.empty());
   EXPECT_NE(result.match_at(0).description, result.match_at(2).description);
 }
 
 TEST_F(SearchProviderTest, KeywordVerbatim) {
   TestData cases[] = {
     // Test a simple keyword input.
     { ASCIIToUTF16("k foo"), 2,
       { ResultInfo(GURL("http://keyword/foo"),
                    AutocompleteMatchType::SEARCH_OTHER_ENGINE,
+                   true,
                    ASCIIToUTF16("k foo")),
         ResultInfo(GURL("http://defaultturl/k%20foo"),
                    AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+                   false,
                    ASCIIToUTF16("k foo") ) } },
 
     // Make sure extra whitespace after the keyword doesn't change the
     // keyword verbatim query.
     { ASCIIToUTF16("k   foo"), 2,
       { ResultInfo(GURL("http://keyword/foo"),
                    AutocompleteMatchType::SEARCH_OTHER_ENGINE,
+                   true,
                    ASCIIToUTF16("k foo")),
         ResultInfo(GURL("http://defaultturl/k%20%20%20foo"),
                    AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+                   false,
                    ASCIIToUTF16("k   foo")) } },
     // Leading whitespace should be stripped before SearchProvider gets the
     // input; hence there are no tests here about how it handles those inputs.
 
     // But whitespace elsewhere in the query string should matter to both
     // matches.
     { ASCIIToUTF16("k  foo  bar"), 2,
       { ResultInfo(GURL("http://keyword/foo%20%20bar"),
                    AutocompleteMatchType::SEARCH_OTHER_ENGINE,
+                   true,
                    ASCIIToUTF16("k foo  bar")),
         ResultInfo(GURL("http://defaultturl/k%20%20foo%20%20bar"),
                    AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+                   false,
                    ASCIIToUTF16("k  foo  bar")) } },
     // Note in the above test case we don't test trailing whitespace because
     // SearchProvider still doesn't handle this well.  See related bugs:
     // 102690, 99239, 164635.
 
     // Keywords can be prefixed by certain things that should get ignored
     // when constructing the keyword match.
     { ASCIIToUTF16("www.k foo"), 2,
       { ResultInfo(GURL("http://keyword/foo"),
                    AutocompleteMatchType::SEARCH_OTHER_ENGINE,
+                   true,
                    ASCIIToUTF16("k foo")),
         ResultInfo(GURL("http://defaultturl/www.k%20foo"),
                    AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+                   false,
                    ASCIIToUTF16("www.k foo")) } },
     { ASCIIToUTF16("http://k foo"), 2,
       { ResultInfo(GURL("http://keyword/foo"),
                    AutocompleteMatchType::SEARCH_OTHER_ENGINE,
+                   true,
                    ASCIIToUTF16("k foo")),
         ResultInfo(GURL("http://defaultturl/http%3A//k%20foo"),
                    AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+                   false,
                    ASCIIToUTF16("http://k foo")) } },
     { ASCIIToUTF16("http://www.k foo"), 2,
       { ResultInfo(GURL("http://keyword/foo"),
                    AutocompleteMatchType::SEARCH_OTHER_ENGINE,
+                   true,
                    ASCIIToUTF16("k foo")),
         ResultInfo(GURL("http://defaultturl/http%3A//www.k%20foo"),
                    AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+                   false,
                    ASCIIToUTF16("http://www.k foo")) } },
 
     // A keyword with no remaining input shouldn't get a keyword
     // verbatim match.
     { ASCIIToUTF16("k"), 1,
       { ResultInfo(GURL("http://defaultturl/k"),
                    AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+                   true,
                    ASCIIToUTF16("k")) } },
     { ASCIIToUTF16("k "), 1,
       { ResultInfo(GURL("http://defaultturl/k%20"),
                    AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+                   true,
                    ASCIIToUTF16("k ")) } }
 
     // The fact that verbatim queries to keyword are handled by KeywordProvider
     // not SearchProvider is tested in
     // chrome/browser/extensions/api/omnibox/omnibox_apitest.cc.
   };
 
   // Test not in keyword mode.
   RunTest(cases, arraysize(cases), false);
 
@@ skipping 17 matching lines @@
 
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(switches::kGoogleBaseURL,
                                                       "http://www.bar.com/");
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kExtraSearchQueryParams, "a=b");
 
   TestData cases[] = {
     { ASCIIToUTF16("k a"), 2,
       { ResultInfo(GURL("http://keyword/a"),
                    AutocompleteMatchType::SEARCH_OTHER_ENGINE,
+                   true,
                    ASCIIToUTF16("k a")),
         ResultInfo(GURL("http://www.bar.com/k%20a?a=b"),
                    AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+                   false,
                    ASCIIToUTF16("k a")) } },
   };
 
   RunTest(cases, arraysize(cases), false);
 }
 
 // Verifies Navsuggest results don't set a TemplateURL, which Instant relies on.
 // Also verifies that just the *first* navigational result is listed as a match
 // if suggested relevance scores were not sent.
 TEST_F(SearchProviderTest, NavSuggestNoSuggestedRelevanceScores) {
@@ skipping 623 matching lines @@
         test_factory_.GetFetcherByID(
             SearchProvider::kDefaultProviderURLFetcherID);
     ASSERT_TRUE(fetcher);
     fetcher->set_response_code(200);
     fetcher->SetResponseString(cases[i].json);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunTillProviderDone();
 
     const std::string description = "for input with json=" + cases[i].json;
     const ACMatches& matches = provider_->matches();
-    // The top match must inline and score as highly as calculated verbatim.
     ASSERT_FALSE(matches.empty());
+    // Find the first match that's allowed to be the default match and check

[msw, 2013/11/20 21:05:03]

I know you only added this code in two places, but perhaps this deserves a
helper function to parallel SearchProvider::FindTopMatch.

[Mark P, 2013/11/21 21:30:22]

Okay, done.

+    // its inline_autocompletion.
+    ACMatches::const_iterator it = matches.begin();
+    while ((it != matches.end()) && !it->allowed_to_be_default_match)
+      ++it;
+    ASSERT_NE(matches.end(), it);
     EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
-              matches[0].inline_autocompletion) << description;
+              it->inline_autocompletion) << description;
 
     ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
       EXPECT_EQ(ASCIIToUTF16(cases[i].matches[j].contents),
                 matches[j].contents) << description;
       EXPECT_EQ(cases[i].matches[j].allowed_to_be_default_match,
                 matches[j].allowed_to_be_default_match) << description;
     }
@@ skipping 22 matching lines @@
   struct {
     const std::string json;
     const KeywordFetcherMatch matches[6];
     const std::string inline_autocompletion;
   } cases[] = {
     // Ensure that suggest relevance scores reorder matches and that
     // the keyword verbatim (lacking a suggested verbatim score) beats
     // the default provider verbatim.
     { "[\"a\",[\"b\", \"c\"],[],[],{\"google:suggestrelevance\":[1, 2]}]",
       { { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         { "c",   true,  false },
         { "b",   true,  false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     // Again, check that relevance scores reorder matches, just this
     // time with navigation matches.  This also checks that with
     // suggested relevance scores we allow multiple navsuggest results.
-    // It's odd that navsuggest results that come from a keyword
-    // provider are marked as not a keyword result.  I think this
-    // comes from them not going to a keyword search engine).
-    // TODO(mpearson): Investigate the implications (if any) of
-    // tagging these results appropriately.  If so, do it because it
-    // makes more sense.
+    // Note that navsuggest results that come from a keyword provider
+    // are marked as not a keyword result.  (They don't go to a
+    // keyword search engine.)
     { "[\"a\",[\"http://b.com\", \"http://c.com\", \"d\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
        "\"google:suggestrelevance\":[1301, 1302, 1303]}]",
       { { "a",     true,  true },
         { "d",     true,  false },
         { "c.com", false, false },
         { "b.com", false, false },
-        { "k a",   false, true },
+        { "k a",   false, false },
         kEmptyMatch },
       std::string() },
 
     // Without suggested relevance scores, we should only allow one
     // navsuggest result to be be displayed.
     { "[\"a\",[\"http://b.com\", \"http://c.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"]}]",
       { { "a",     true,  true },
         { "b.com", false, false },
-        { "k a",   false, true },
+        { "k a",   false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Ensure that verbatimrelevance scores reorder or suppress verbatim.
     // Negative values will have no effect; the calculated value will be used.
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":9999,"
                              "\"google:suggestrelevance\":[9998]}]",
       { { "a",   true,  true },
         { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":9998,"
                              "\"google:suggestrelevance\":[9999]}]",
       { { "a1",  true,  true },
         { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0,"
                              "\"google:suggestrelevance\":[9999]}]",
       { { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":-1,"
                              "\"google:suggestrelevance\":[9999]}]",
       { { "a1",  true,  true },
         { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9999,"
         "\"google:suggestrelevance\":[9998]}]",
       { { "a",     true,  true },
-        { "a.com", false, true },
-        { "k a",   false, true },
+        { "a.com", false, false },

[msw, 2013/11/20 21:05:03]

This is the only behavior change that seems questionable. If the user types "k
a" and the keyword provider 'k' says "go to a.com! that's my top result!", then
we'll stomp the suggestion because it'll kick the user out of keyword mode... I
think the right right solution is to somehow allow navigation suggestions from
the keyword provider to be default matches without kicking the user out of
keyword mode, though that seems impossible given the current architecture.

So, while I think you're making the right change for now, we should keep the
'right' solution in mind, and perhaps file a bug in case we ever have the
opportunity to allow keyword navigation matches to be default...

[Mark P, 2013/11/21 21:30:22]

Acknowledged.  Filed https://code.google.com/p/chromium/issues/detail?id=322156

+        { "k a",   false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Ensure that both types of relevance scores reorder matches together.
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[9999, 9997],"
                                      "\"google:verbatimrelevance\":9998}]",
       { { "a1",  true,  true },
         { "a",   true,  true },
         { "a2",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       "1" },
 
     // Ensure that only inlinable matches may be ranked as the highest result.
     // Ignore all suggested relevance scores if this constraint is violated.
     { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999]}]",
       { { "a",   true,  true },
         { "b",   true,  false },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999],"
                             "\"google:verbatimrelevance\":0}]",
       { { "a",   true,  true },
         { "b",   true,  false },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999]}]",
       { { "a",     true,  true },
         { "b.com", false, false },
-        { "k a",   false, true },
+        { "k a",   false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999],"
         "\"google:verbatimrelevance\":0}]",
       { { "a",     true,  true },
         { "b.com", false, false },
-        { "k a",   false, true },
+        { "k a",   false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Ensure that the top result is ranked as highly as calculated verbatim.
     // Ignore the suggested verbatim relevance if this constraint is violated.
     // Note that keyword suggestions by default (not in suggested relevance
     // mode) score more highly than the default verbatim.
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0}]",
       { { "a",   true,  true },
         { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":1}]",
       { { "a",   true,  true },
         { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     // Continuing the same category of tests, but make sure we keep the
     // suggested relevance scores even as we discard the verbatim relevance
     // scores.
     { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[1],"
                              "\"google:verbatimrelevance\":0}]",
       { { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         { "a1",   true, true },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 2],"
                                      "\"google:verbatimrelevance\":0}]",
       { { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         { "a2",  true,  true },
         { "a1",  true,  true },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 3],"
       "\"google:verbatimrelevance\":2}]",
       { { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         { "a2",  true,  true },
         { "a1",  true,  true },
         kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Ensure that all suggestions are considered, regardless of order.
     { "[\"a\",[\"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\"],[],[],"
        "{\"google:suggestrelevance\":[1, 2, 3, 4, 5, 6, 7]}]",
       { { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         { "h",   true,  false },
         { "g",   true,  false },
         { "f",   true,  false },
         { "e",   true,  false } },
       std::string() },
     { "[\"a\",[\"http://b.com\", \"http://c.com\", \"http://d.com\","
               "\"http://e.com\", \"http://f.com\", \"http://g.com\","
               "\"http://h.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\","
                                 "\"NAVIGATION\", \"NAVIGATION\","
                                 "\"NAVIGATION\", \"NAVIGATION\","
                                 "\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[1, 2, 3, 4, 5, 6, 7]}]",
       { { "a",     true,  true },
-        { "k a",   false, true },
+        { "k a",   false, false },
         { "h.com", false, false },
         { "g.com", false, false },
         { "f.com", false, false },
         { "e.com", false, false } },
       std::string() },
 
     // Ensure that incorrectly sized suggestion relevance lists are ignored.
     // Note that keyword suggestions by default (not in suggested relevance
     // mode) score more highly than the default verbatim.
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1]}]",
       { { "a",   true,  true },
         { "a1",  true,  true },
         { "a2",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[9999, 1]}]",
       { { "a",   true,  true },
         { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     // In this case, ignoring the suggested relevance scores means we keep
     // only one navsuggest result.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:suggestrelevance\":[1]}]",
       { { "a",      true,  true },
-        { "a1.com", false, true },
-        { "k a",    false, true },
+        { "a1.com", false, false },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
        "\"google:suggestrelevance\":[9999, 1]}]",
       { { "a",      true,  true },
-        { "a1.com", false, true },
-        { "k a",    false, true },
+        { "a1.com", false, false },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Ensure that all 'verbatim' results are merged with their maximum score.
     { "[\"a\",[\"a\", \"a1\", \"a2\"],[],[],"
        "{\"google:suggestrelevance\":[9998, 9997, 9999]}]",
       { { "a2",  true,  true },
         { "a",   true,  true },
         { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       "2" },
     { "[\"a\",[\"a\", \"a1\", \"a2\"],[],[],"
        "{\"google:suggestrelevance\":[9998, 9997, 9999],"
         "\"google:verbatimrelevance\":0}]",
       { { "a2",  true,  true },
         { "a",   true,  true },
         { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       "2" },
 
     // Ensure that verbatim is always generated without other suggestions.
     // TODO(mpearson): Ensure the value of verbatimrelevance is respected
     // (except when suggested relevances are ignored).
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":1}]",
       { { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":0}]",
       { { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Check that navsuggestions will be demoted below queries.
     // (Navsuggestions are not allowed to appear first.)  In the process,
     // make sure the navsuggestions still remain in the same order.
     // First, check the situation where navsuggest scores more than verbatim
     // and there are no query suggestions.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9999]}]",
       { { "a",      true,  true },
-        { "a2.com", false, true },
-        { "a1.com", false, true },
-        { "k a",    false, true },
+        { "a2.com", false, false },
+        { "a1.com", false, false },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9999, 9998]}]",
       { { "a",      true,  true },
-        { "a1.com", false, true },
-        { "a2.com", false, true },
-        { "k a",    false, true },
+        { "a1.com", false, false },
+        { "a2.com", false, false },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"https://a/\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999]}]",
-      { { "a",         true, true },
-        { "https://a", false, true },
-        { "k a",       false, true },
+      { { "a",         true,  true },
+        { "https://a", false, false },
+        { "k a",       false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     // Check when navsuggest scores more than verbatim and there is query
     // suggestion but it scores lower.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9999, 1300]}]",
       { { "a",      true,  true },
-        { "a2.com", false, true },
-        { "a1.com", false, true },
+        { "a2.com", false, false },
+        { "a1.com", false, false },
         { "a3",     true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9999, 9998, 1300]}]",
       { { "a",      true,  true },
-        { "a1.com", false, true },
-        { "a2.com", false, true },
+        { "a1.com", false, false },
+        { "a2.com", false, false },
         { "a3",     true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       std::string() },
     // Check when navsuggest scores more than a query suggestion.  There is
     // a verbatim but it scores lower.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9999, 9997]}]",
       { { "a3",     true,  true },
-        { "a2.com", false, true },
-        { "a1.com", false, true },
+        { "a2.com", false, false },
+        { "a1.com", false, false },
         { "a",      true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9999, 9998, 9997]}]",
       { { "a3",     true,  true },
-        { "a1.com", false, true },
-        { "a2.com", false, true },
+        { "a1.com", false, false },
+        { "a2.com", false, false },
         { "a",      true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9998, 9999, 9997]}]",
       { { "a3",     true,  true },
-        { "a2.com", false, true },
-        { "a1.com", false, true },
-        { "k a",    false, true },
+        { "a2.com", false, false },
+        { "a1.com", false, false },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9999, 9998, 9997]}]",
       { { "a3",     true,  true },
-        { "a1.com", false, true },
-        { "a2.com", false, true },
-        { "k a",    false, true },
+        { "a1.com", false, false },
+        { "a2.com", false, false },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       "3" },
     // Check when there is neither verbatim nor a query suggestion that,
     // because we can't demote navsuggestions below a query suggestion,
     // we abandon suggested relevance scores entirely.  One consequence is
     // that this means we restore the keyword verbatim match.  Note
     // that in this case of abandoning suggested relevance scores, we still
     // keep the navsuggestions in the same order, but we revert to only allowing
     // one navigation to appear because the scores are completely local.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9998, 9999]}]",
       { { "a",      true,  true },
-        { "a2.com", false, true },
-        { "k a",    false, true },
+        { "a2.com", false, false },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9999, 9998]}]",
       { { "a",      true,  true },
-        { "a1.com", false, true },
-        { "k a",    false, true },
+        { "a1.com", false, false },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     // More checks that everything works when it's not necessary to demote.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9997, 9998, 9999]}]",
       { { "a3",     true,  true },
-        { "a2.com", false, true },
-        { "a1.com", false, true },
+        { "a2.com", false, false },
+        { "a1.com", false, false },
         { "a",      true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9997, 9999]}]",
       { { "a3",     true,  true },
-        { "a1.com", false, true },
-        { "a2.com", false, true },
+        { "a1.com", false, false },
+        { "a2.com", false, false },
         { "a",      true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       "3" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(ASCIIToUTF16("k a"), false, true);
 
     // Set up a default fetcher with no results.
     net::TestURLFetcher* default_fetcher =
         test_factory_.GetFetcherByID(
@@ skipping 56 matching lines @@
   struct {
     const std::string json;
     const KeywordFetcherMatch matches[6];
     const std::string inline_autocompletion;
   } cases[] = {
     // Ensure that suggest relevance scores reorder matches and that
     // the keyword verbatim (lacking a suggested verbatim score) beats
     // the default provider verbatim.
     { "[\"a\",[\"b\", \"c\"],[],[],{\"google:suggestrelevance\":[1, 2]}]",
       { { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         { "c",   true,  false },
         { "b",   true,  false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     // Again, check that relevance scores reorder matches, just this
     // time with navigation matches.  This also checks that with
     // suggested relevance scores we allow multiple navsuggest results.
-    // It's odd that navsuggest results that come from a keyword
-    // provider are marked as not a keyword result.  I think this
-    // comes from them not going to a keyword search engine.
-    // TODO(mpearson): Investigate the implications (if any) of
-    // tagging these results appropriately.  If so, do it because it
-    // makes more sense.
+    // Note that navsuggest results that come from a keyword provider
+    // are marked as not a keyword result.  (They don't go to a
+    // keyword search engine.)
     { "[\"a\",[\"http://b.com\", \"http://c.com\", \"d\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
        "\"google:suggestrelevance\":[1301, 1302, 1303]}]",
       { { "a",     true,  true },
         { "d",     true,  false },
         { "c.com", false, false },
         { "b.com", false, false },
-        { "k a",   false, true },
+        { "k a",   false, false },
         kEmptyMatch },
       std::string() },
 
     // Without suggested relevance scores, we should only allow one
     // navsuggest result to be be displayed.
     { "[\"a\",[\"http://b.com\", \"http://c.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"]}]",
       { { "a",     true,  true },
         { "b.com", false, false },
-        { "k a",   false, true },
+        { "k a",   false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Ensure that verbatimrelevance scores reorder or suppress verbatim.
     // Negative values will have no effect; the calculated value will be used.
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":9999,"
                              "\"google:suggestrelevance\":[9998]}]",
       { { "a",   true,  true },
         { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":9998,"
                              "\"google:suggestrelevance\":[9999]}]",
       { { "a1",  true,  true },
         { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0,"
                              "\"google:suggestrelevance\":[9999]}]",
       { { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":-1,"
                              "\"google:suggestrelevance\":[9999]}]",
       { { "a1",  true,  true },
         { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9999,"
         "\"google:suggestrelevance\":[9998]}]",
       { { "a",     true,  true },
-        { "a.com", false, true },
-        { "k a",   false, true },
+        { "a.com", false, false },
+        { "k a",   false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Ensure that both types of relevance scores reorder matches together.
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[9999, 9997],"
                                      "\"google:verbatimrelevance\":9998}]",
       { { "a1",  true,  true },
         { "a",   true,  true },
         { "a2",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       "1" },
 
     // Check that non-inlinable matches may be ranked as the highest result
     // if there is at least one inlineable match.
     { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999]}]",
       { { "b",   true,  false },
         { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
-    { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999],"
-                            "\"google:verbatimrelevance\":0}]",
-      { { "b",   true,  false },
-        { "k a", false, true },
-        kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
-      std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999]}]",
       { { "b.com", false, false },
         { "a",     true,  true },
-        { "k a",   false, true },
+        { "k a",   false, false },
+        kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      std::string() },
+    // On the other hand, if there is no inlineable match, restore

[msw, 2013/11/20 21:05:03]

Nice, I think this is a good behavior change!

[Mark P, 2013/11/21 21:30:22]

Acknowledged.  (Thanks!)

+    // the keyword verbatim score.
+    { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999],"
+                            "\"google:verbatimrelevance\":0}]",
+      { { "b",   true,  false },
+        { "a",   true,  true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999],"
         "\"google:verbatimrelevance\":0}]",
       { { "b.com", false, false },
-        { "k a",   false, true },
-        kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+        { "a",     true,  true },
+        { "k a",   false, false },
+        kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // The top result does not have to score as highly as calculated
     // verbatim.  i.e., there are no minimum score restrictions in
     // this provider.
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0}]",
       { { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":1}]",
       { { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         { "a",   true,  true },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[1],"
                              "\"google:verbatimrelevance\":0}]",
-      { { "k a", false, true },
+      { { "k a", false, false },
         { "a1",   true, true },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
-      std::string() },
+      "1" },
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 2],"
                                      "\"google:verbatimrelevance\":0}]",
       {
-        { "k a", false, true },
+        { "k a", false, false },
         { "a2",  true,  true },
         { "a1",  true,  true },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
-      std::string() },
+      "2" },
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 3],"
       "\"google:verbatimrelevance\":2}]",
-      { { "k a", false, true },
+      { { "k a", false, false },
         { "a2",  true,  true },
         { "a",   true,  true },
         { "a1",  true,  true },
         kEmptyMatch, kEmptyMatch },
-      std::string() },
+      "2" },
 
     // Ensure that all suggestions are considered, regardless of order.
     { "[\"a\",[\"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\"],[],[],"
        "{\"google:suggestrelevance\":[1, 2, 3, 4, 5, 6, 7]}]",
       { { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         { "h",   true,  false },
         { "g",   true,  false },
         { "f",   true,  false },
         { "e",   true,  false } },
       std::string() },
     { "[\"a\",[\"http://b.com\", \"http://c.com\", \"http://d.com\","
               "\"http://e.com\", \"http://f.com\", \"http://g.com\","
               "\"http://h.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\","
                                 "\"NAVIGATION\", \"NAVIGATION\","
                                 "\"NAVIGATION\", \"NAVIGATION\","
                                 "\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[1, 2, 3, 4, 5, 6, 7]}]",
       { { "a",     true,  true },
-        { "k a",   false, true },
+        { "k a",   false, false },
         { "h.com", false, false },
         { "g.com", false, false },
         { "f.com", false, false },
         { "e.com", false, false } },
       std::string() },
 
     // Ensure that incorrectly sized suggestion relevance lists are ignored.
     // Note that keyword suggestions by default (not in suggested relevance
     // mode) score more highly than the default verbatim.
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1]}]",
       { { "a",   true,  true },
         { "a1",  true,  true },
         { "a2",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[9999, 1]}]",
       { { "a",   true,  true },
         { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     // In this case, ignoring the suggested relevance scores means we keep
     // only one navsuggest result.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:suggestrelevance\":[1]}]",
       { { "a",      true,  true },
-        { "a1.com", false, true },
-        { "k a",    false, true },
+        { "a1.com", false, false },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
        "\"google:suggestrelevance\":[9999, 1]}]",
       { { "a",      true,  true },
-        { "a1.com", false, true },
-        { "k a",    false, true },
+        { "a1.com", false, false },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Ensure that all 'verbatim' results are merged with their maximum score.
     { "[\"a\",[\"a\", \"a1\", \"a2\"],[],[],"
        "{\"google:suggestrelevance\":[9998, 9997, 9999]}]",
       { { "a2",  true,  true },
         { "a",   true,  true },
         { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       "2" },
     { "[\"a\",[\"a\", \"a1\", \"a2\"],[],[],"
        "{\"google:suggestrelevance\":[9998, 9997, 9999],"
         "\"google:verbatimrelevance\":0}]",
       { { "a2",  true,  true },
         { "a",   true,  true },
         { "a1",  true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       "2" },
 
     // Ensure that verbatim is always generated without other suggestions.
     // TODO(mpearson): Ensure the value of verbatimrelevance is respected
     // (except when suggested relevances are ignored).
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":1}]",
-      { { "k a", false, true },
+      { { "k a", false, false },
         { "a",   true,  true },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":0}]",
       { { "a",   true,  true },
-        { "k a", false, true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
-    // Check that navsuggestions will be demoted below queries.
-    // (Navsuggestions are not allowed to appear first.)  In the process,
-    // make sure the navsuggestions still remain in the same order.
-    // First, check the situation where navsuggest scores more than verbatim
-    // and there are no query suggestions.
+    // In reorder mode, navsuggestions will not need to be demoted (because
+    // they are marked as not allowed to be default match and will be
+    // reordered as necessary).
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9999]}]",
-      { { "a",      true,  true },
-        { "a2.com", false, true },
-        { "a1.com", false, true },
-        { "k a",    false, true },
+      { { "a2.com", false, false },
+        { "a1.com", false, false },
+        { "a",      true,  true },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9999, 9998]}]",
-      { { "a",      true,  true },
-        { "a1.com", false, true },
-        { "a2.com", false, true },
-        { "k a",    false, true },
+      { { "a1.com", false, false },
+        { "a2.com", false, false },
+        { "a",      true,  true },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"https://a/\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999]}]",
-      { { "a",         true,  true },
-        { "https://a", false, true },
-        { "k a",       false, true },
+      { { "https://a", false, false },
+        { "a",         true,  true },
+        { "k a",       false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     // Check when navsuggest scores more than verbatim and there is query
     // suggestion but it scores lower.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9999, 1300]}]",
-      { { "a",      true,  true },
-        { "a2.com", false, true },
-        { "a1.com", false, true },
+      { { "a2.com", false, false },
+        { "a1.com", false, false },
+        { "a",      true,  true },
         { "a3",     true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9999, 9998, 1300]}]",
-      { { "a",      true,  true },
-        { "a1.com", false, true },
-        { "a2.com", false, true },
+      { { "a1.com", false, false },
+        { "a2.com", false, false },
+        { "a",      true,  true },
         { "a3",     true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       std::string() },
     // Check when navsuggest scores more than a query suggestion.  There is
     // a verbatim but it scores lower.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9999, 9997]}]",
-      { { "a3",     true,  true },
-        { "a2.com", false, true },
-        { "a1.com", false, true },
+      { { "a2.com", false, false },
+        { "a1.com", false, false },
+        { "a3",     true,  true },
         { "a",      true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9999, 9998, 9997]}]",
-      { { "a3",     true,  true },
-        { "a1.com", false, true },
-        { "a2.com", false, true },
+      { { "a1.com", false, false },
+        { "a2.com", false, false },
+        { "a3",     true,  true },
         { "a",      true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9998, 9999, 9997]}]",
-      { { "a3",     true,  true },
-        { "a2.com", false, true },
-        { "a1.com", false, true },
-        { "k a",    false, true },
+      { { "a2.com", false, false },
+        { "a1.com", false, false },
+        { "a3",     true,  true },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9999, 9998, 9997]}]",
-      { { "a3",     true,  true },
-        { "a1.com", false, true },
-        { "a2.com", false, true },
-        { "k a",    false, true },
+      { { "a1.com", false, false },
+        { "a2.com", false, false },
+        { "a3",     true,  true },
+        { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       "3" },
     // Check when there is neither verbatim nor a query suggestion that,
     // because we can't demote navsuggestions below a query suggestion,
-    // we abandon suggested relevance scores entirely.  One consequence is
-    // that this means we restore the keyword verbatim match.  Note
-    // that in this case of abandoning suggested relevance scores, we still
-    // keep the navsuggestions in the same order, but we revert to only allowing
-    // one navigation to appear because the scores are completely local.
+    // we restore the keyword verbatim score.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9998, 9999]}]",
-      { { "a",      true,  true },
-        { "a2.com", false, true },
-        { "k a",    false, true },
-        kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      { { "a2.com", false, false },
+        { "a1.com", false, false },
+        { "a",      true,  true },
+        { "k a",    false, false },
+        kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9999, 9998]}]",
-      { { "a",      true,  true },
-        { "a1.com", false, true },
-        { "k a",    false, true },
-        kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      { { "a1.com", false, false },
+        { "a2.com", false, false },
+        { "a",      true,  true },
+        { "k a",    false, false },
+        kEmptyMatch, kEmptyMatch },
       std::string() },
     // More checks that everything works when it's not necessary to demote.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9997, 9998, 9999]}]",
       { { "a3",     true,  true },
-        { "a2.com", false, true },
-        { "a1.com", false, true },
+        { "a2.com", false, false },
+        { "a1.com", false, false },
         { "a",      true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9997, 9999]}]",
       { { "a3",     true,  true },
-        { "a1.com", false, true },
-        { "a2.com", false, true },
+        { "a1.com", false, false },
+        { "a2.com", false, false },
         { "a",      true,  true },
-        { "k a",    false, true },
+        { "k a",    false, false },
         kEmptyMatch },
       "3" },
   };
 
   std::map<std::string, std::string> params;
   params[std::string(OmniboxFieldTrial::kReorderForLegalDefaultMatchRule) +
       ":*:*"] = OmniboxFieldTrial::kReorderForLegalDefaultMatchRuleEnabled;
   ASSERT_TRUE(chrome_variations::AssociateVariationParams(
       OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A", params));
   base::FieldTrialList::CreateFieldTrial(
@@ skipping 17 matching lines @@
             SearchProvider::kKeywordProviderURLFetcherID);
     ASSERT_TRUE(keyword_fetcher);
     keyword_fetcher->set_response_code(200);
     keyword_fetcher->SetResponseString(cases[i].json);
     keyword_fetcher->delegate()->OnURLFetchComplete(keyword_fetcher);
     keyword_fetcher = NULL;
     RunTillProviderDone();
 
     const std::string description = "for input with json=" + cases[i].json;
     const ACMatches& matches = provider_->matches();
-    // The top match must inline and score as highly as calculated verbatim.
     ASSERT_FALSE(matches.empty());
+    // Find the first match that's allowed to be the default match and check
+    // its inline_autocompletion.
+    ACMatches::const_iterator it = matches.begin();
+    while ((it != matches.end()) && !it->allowed_to_be_default_match)
+      ++it;
+    ASSERT_NE(matches.end(), it);
     EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
-              matches[0].inline_autocompletion) << description;
+              it->inline_autocompletion) << description;
 
     ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
       EXPECT_EQ(ASCIIToUTF16(cases[i].matches[j].contents),
                 matches[j].contents) << description;
       EXPECT_EQ(cases[i].matches[j].from_keyword,
                 matches[j].keyword == ASCIIToUTF16("k")) << description;
       EXPECT_EQ(cases[i].matches[j].allowed_to_be_default_match,
@@ skipping 1372 matching lines @@
       AutocompleteInput::OTHER, &profile_));
   encrypted_types.Remove(syncer::SESSIONS);
   service->OnEncryptedTypesChanged(encrypted_types, false);
 
   // Check that there were no side effects from previous tests.
   EXPECT_TRUE(SearchProvider::CanSendURL(
       GURL("http://www.google.com/search"),
       GURL("https://www.google.com/complete/search"), &google_template_url,
       AutocompleteInput::OTHER, &profile_));
 }