Omnibox: Make the Controller Reorder Matches for Inlining

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 "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/autocomplete/history_url_provider.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/omnibox/omnibox_field_trial.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/metrics/entropy_provider.h"
+#include "chrome/common/metrics/variations/variations_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 
 // SearchProviderTest ---------------------------------------------------------
@@ skipping 31 matching lines @@
     const size_t num_results;
     const ResultInfo output[3];
   };
 
   SearchProviderTest()
       : default_t_url_(NULL),
         term1_(ASCIIToUTF16("term1")),
         keyword_t_url_(NULL),
         keyword_term_(ASCIIToUTF16("keyword")),
         run_loop_(NULL) {
+    ResetFieldTrialList();
   }
 
-  static void SetUpTestCase();
   static void TearDownTestCase();
 
   // See description above class for what this registers.
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   void RunTest(TestData* cases, int num_cases, bool prefer_keyword);
 
  protected:
   // Needed for AutocompleteFieldTrial::ActivateStaticTrials();
@@ skipping 31 matching lines @@
   // Calls QueryForInput(), finishes any suggest query, then if |wyt_match| is
   // non-NULL, sets it to the "what you typed" entry for |text|.
   void QueryForInputAndSetWYTMatch(const string16& text,
                                    AutocompleteMatch* wyt_match);
 
   // 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();
 
+  static void ResetFieldTrialList();
+
   // See description above class for details of these fields.
   TemplateURL* default_t_url_;
   const string16 term1_;
   GURL term1_url_;
   TemplateURL* keyword_t_url_;
   const string16 keyword_term_;
   GURL keyword_url_;
 
   content::TestBrowserThreadBundle thread_bundle_;
 
@@ skipping 10 matching lines @@
   base::RunLoop* run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SearchProviderTest);
 };
 
 // static
 base::FieldTrialList* SearchProviderTest::field_trial_list_ = NULL;
 const std::string SearchProviderTest::kNotApplicable = "Not Applicable";
 
 // static
-void SearchProviderTest::SetUpTestCase() {
-  // Set up Suggest experiments.
-  field_trial_list_ = new base::FieldTrialList(
-      new metrics::SHA1EntropyProvider("foo"));
-  base::FieldTrial* trial = base::FieldTrialList::CreateFieldTrial(
-      "AutocompleteDynamicTrial_0", "DefaultGroup");
-  trial->group();
-}
-
-// static
 void SearchProviderTest::TearDownTestCase() {
   // Make sure the global instance of FieldTrialList is gone.
   delete field_trial_list_;
+  field_trial_list_ = NULL;
 }
 
 void SearchProviderTest::SetUp() {
   // Make sure that fetchers are automatically ungregistered upon destruction.
   test_factory_.set_remove_fetcher_on_delete(true);
 
   // We need both the history service and template url model loaded.
   ASSERT_TRUE(profile_.CreateHistoryService(true, false));
   TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
@@ skipping 64 matching lines @@
     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;
+        // All callers that use this helper function at the moment produce
+        // matches that always allowed to be the default match.
+        EXPECT_TRUE(matches[j].allowed_to_be_default_match);
       }
     }
   }
 }
 
 void SearchProviderTest::OnProviderUpdate(bool updated_matches) {
   if (run_loop_ && provider_->done()) {
     run_loop_->Quit();
     run_loop_ = NULL;
   }
@@ skipping 83 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);
 }
 
+// static
+void SearchProviderTest::ResetFieldTrialList() {
+  // It's important to delete the old pointer first which sets
+  // FieldTrialList::global_ to NULL.
+  if (field_trial_list_)
+    delete field_trial_list_;
+  field_trial_list_ = new base::FieldTrialList(
+      new metrics::SHA1EntropyProvider("foo"));
+//TODO: uncomment me!  chrome_variations::testing::ClearAllVariationParams();

[H Fung, 2013/08/06 22:03:17]

Don't forget to uncomment/remove?

[Mark P, 2013/08/06 22:18:06]

Good point.  I cannot uncomment this until
https://codereview.chromium.org/22031002/
lands.

I added something to the changelist description to remind me.

+//  OmniboxFieldTrial::ActivateDynamicTrials();
+  base::FieldTrial* trial = base::FieldTrialList::CreateFieldTrial(
+      "AutocompleteDynamicTrial_0", "DefaultGroup");
+  trial->group();
+}
 
 // Actual Tests ---------------------------------------------------------------
 
 // Make sure we query history for the default provider and a URLFetcher is
 // created for the default provider suggest results.
 TEST_F(SearchProviderTest, QueryDefaultProvider) {
   string16 term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, false, false);
 
   // Make sure the default providers suggest service was queried.
@@ skipping 20 matching lines @@
   EXPECT_TRUE(FindMatchWithDestination(term1_url_, &term1_match));
   // Term1 should not have a description, it's set later.
   EXPECT_TRUE(term1_match.description.empty());
 
   AutocompleteMatch wyt_match;
   EXPECT_TRUE(FindMatchWithDestination(
       GURL(default_t_url_->url_ref().ReplaceSearchTerms(
           TemplateURLRef::SearchTermsArgs(term))), &wyt_match));
   EXPECT_TRUE(wyt_match.description.empty());
 
-  // The match for term1 should be more relevant than the what you typed result.
+  // The match for term1 should be more relevant than the what you typed match.
   EXPECT_GT(term1_match.relevance, wyt_match.relevance);
+  // This longer match should be inlineable.
+  EXPECT_TRUE(term1_match.allowed_to_be_default_match);
+  // The what you typed match should too of course.
+  EXPECT_TRUE(wyt_match.allowed_to_be_default_match);
 }
 
 TEST_F(SearchProviderTest, HonorPreventInlineAutocomplete) {
   string16 term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, true, false);
 
   ASSERT_FALSE(provider_->matches().empty());
   ASSERT_EQ(AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
             provider_->matches()[0].type);
+  EXPECT_TRUE(provider_->matches()[0].allowed_to_be_default_match);
 }
 
 // Issues a query that matches the registered keyword and makes sure history
 // is queried as well as URLFetchers getting created.
 TEST_F(SearchProviderTest, QueryKeywordProvider) {
   string16 term = keyword_term_.substr(0, keyword_term_.length() - 1);
   QueryForInput(keyword_t_url_->keyword() + ASCIIToUTF16(" ") + term,
                 false,
                 false);
 
@@ skipping 81 matching lines @@
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("docs"),
                                                       &wyt_match));
 
   // There should be two matches, one for what you typed, the other for
   // '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);
 }
 
 // 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));
   ASSERT_EQ(2u, provider_->matches().size());
   AutocompleteMatch term_match;
   EXPECT_TRUE(FindMatchWithDestination(term_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);
 
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("one se"),
                                                       &wyt_match));
   ASSERT_EQ(2u, provider_->matches().size());
   EXPECT_TRUE(FindMatchWithDestination(term_url, &term_match));
   EXPECT_GT(term_match.relevance, wyt_match.relevance);
+  EXPECT_TRUE(term_match.allowed_to_be_default_match);
+  EXPECT_TRUE(wyt_match.allowed_to_be_default_match);
 }
 
 // A multiword search with more than one visit should autocomplete immediately.
 TEST_F(SearchProviderTest, AutocompleteMultipleVisitsImmediately) {
   GURL term_url(AddSearchToHistory(default_t_url_, ASCIIToUTF16("two searches"),
                                    2));
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteMatch wyt_match;
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("tw"),
                                                       &wyt_match));
   ASSERT_EQ(2u, provider_->matches().size());
   AutocompleteMatch term_match;
   EXPECT_TRUE(FindMatchWithDestination(term_url, &term_match));
   EXPECT_GT(term_match.relevance, wyt_match.relevance);
+  EXPECT_TRUE(term_match.allowed_to_be_default_match);
+  EXPECT_TRUE(wyt_match.allowed_to_be_default_match);
 }
 
 // Autocompletion should work at a word boundary after a space.
 TEST_F(SearchProviderTest, AutocompleteAfterSpace) {
   GURL term_url(AddSearchToHistory(default_t_url_, ASCIIToUTF16("two searches"),
                                    2));
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteMatch wyt_match;
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("two "),
                                                       &wyt_match));
   ASSERT_EQ(2u, provider_->matches().size());
   AutocompleteMatch term_match;
   EXPECT_TRUE(FindMatchWithDestination(term_url, &term_match));
   EXPECT_GT(term_match.relevance, wyt_match.relevance);
+  EXPECT_TRUE(term_match.allowed_to_be_default_match);
+  EXPECT_TRUE(wyt_match.allowed_to_be_default_match);
 }
 
 // Newer multiword searches should score more highly than older ones.
 TEST_F(SearchProviderTest, ScoreNewerSearchesHigher) {
   GURL term_url_a(AddSearchToHistory(default_t_url_,
                                      ASCIIToUTF16("three searches aaa"), 1));
   GURL term_url_b(AddSearchToHistory(default_t_url_,
                                      ASCIIToUTF16("three searches bbb"), 1));
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteMatch wyt_match;
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("three se"),
                                                       &wyt_match));
   ASSERT_EQ(3u, provider_->matches().size());
   AutocompleteMatch term_match_a;
   EXPECT_TRUE(FindMatchWithDestination(term_url_a, &term_match_a));
   AutocompleteMatch term_match_b;
   EXPECT_TRUE(FindMatchWithDestination(term_url_b, &term_match_b));
   EXPECT_GT(term_match_b.relevance, term_match_a.relevance);
   EXPECT_GT(term_match_a.relevance, wyt_match.relevance);
+  EXPECT_TRUE(term_match_b.allowed_to_be_default_match);
+  EXPECT_TRUE(term_match_a.allowed_to_be_default_match);
+  EXPECT_TRUE(wyt_match.allowed_to_be_default_match);
 }
 
 // An autocompleted multiword search should not be replaced by a different
 // autocompletion while the user is still typing a valid prefix.
 TEST_F(SearchProviderTest, DontReplacePreviousAutocompletion) {
   GURL term_url_a(AddSearchToHistory(default_t_url_,
                                      ASCIIToUTF16("four searches aaa"), 2));
   GURL term_url_b(AddSearchToHistory(default_t_url_,
                                      ASCIIToUTF16("four searches bbb"), 1));
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteMatch wyt_match;
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("fo"),
                                                       &wyt_match));
   ASSERT_EQ(3u, provider_->matches().size());
   AutocompleteMatch term_match_a;
   EXPECT_TRUE(FindMatchWithDestination(term_url_a, &term_match_a));
   AutocompleteMatch term_match_b;
   EXPECT_TRUE(FindMatchWithDestination(term_url_b, &term_match_b));
   EXPECT_GT(term_match_a.relevance, wyt_match.relevance);
   EXPECT_GT(wyt_match.relevance, term_match_b.relevance);
+  EXPECT_TRUE(term_match_a.allowed_to_be_default_match);
+  EXPECT_TRUE(term_match_b.allowed_to_be_default_match);
+  EXPECT_TRUE(wyt_match.allowed_to_be_default_match);
 
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("four se"),
                                                       &wyt_match));
   ASSERT_EQ(3u, provider_->matches().size());
   EXPECT_TRUE(FindMatchWithDestination(term_url_a, &term_match_a));
   EXPECT_TRUE(FindMatchWithDestination(term_url_b, &term_match_b));
   EXPECT_GT(term_match_a.relevance, wyt_match.relevance);
   EXPECT_GT(wyt_match.relevance, term_match_b.relevance);
+  EXPECT_TRUE(term_match_a.allowed_to_be_default_match);
+  EXPECT_TRUE(term_match_b.allowed_to_be_default_match);
+  EXPECT_TRUE(wyt_match.allowed_to_be_default_match);
 }
 
 // Non-completable multiword searches should not crowd out single-word searches.
 TEST_F(SearchProviderTest, DontCrowdOutSingleWords) {
   GURL term_url(AddSearchToHistory(default_t_url_, ASCIIToUTF16("five"), 1));
   AddSearchToHistory(default_t_url_, ASCIIToUTF16("five searches bbb"), 1);
   AddSearchToHistory(default_t_url_, ASCIIToUTF16("five searches ccc"), 1);
   AddSearchToHistory(default_t_url_, ASCIIToUTF16("five searches ddd"), 1);
   AddSearchToHistory(default_t_url_, ASCIIToUTF16("five searches eee"), 1);
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteMatch wyt_match;
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("fi"),
                                                       &wyt_match));
   ASSERT_EQ(AutocompleteProvider::kMaxMatches + 1, provider_->matches().size());
   AutocompleteMatch term_match;
   EXPECT_TRUE(FindMatchWithDestination(term_url, &term_match));
   EXPECT_GT(term_match.relevance, wyt_match.relevance);
+  EXPECT_TRUE(term_match.allowed_to_be_default_match);
+  EXPECT_TRUE(wyt_match.allowed_to_be_default_match);
 }
 
 // Inline autocomplete matches regardless of case differences from the input.
 TEST_F(SearchProviderTest, InlineMixedCaseMatches) {
   GURL term_url(AddSearchToHistory(default_t_url_, ASCIIToUTF16("FOO"), 1));
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteMatch wyt_match;
   ASSERT_NO_FATAL_FAILURE(QueryForInputAndSetWYTMatch(ASCIIToUTF16("f"),
                                                       &wyt_match));
   ASSERT_EQ(2u, provider_->matches().size());
   AutocompleteMatch term_match;
   EXPECT_TRUE(FindMatchWithDestination(term_url, &term_match));
   EXPECT_GT(term_match.relevance, wyt_match.relevance);
   EXPECT_EQ(ASCIIToUTF16("FOO"), term_match.fill_into_edit);
   EXPECT_EQ(ASCIIToUTF16("OO"), term_match.inline_autocompletion);
+  EXPECT_TRUE(term_match.allowed_to_be_default_match);
 }
 
 // Verifies AutocompleteControllers return results (including keyword
 // results) in the right order and set descriptions for them correctly.
 TEST_F(SearchProviderTest, KeywordOrderingAndDescriptions) {
   // Add an entry that corresponds to a keyword search with 'term2'.
   AddSearchToHistory(keyword_t_url_, ASCIIToUTF16("term2"), 1);
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteController controller(&profile_, NULL,
       AutocompleteProvider::TYPE_SEARCH);
   controller.Start(AutocompleteInput(
       ASCIIToUTF16("k t"), string16::npos, string16(), GURL(),
       AutocompleteInput::INVALID_SPEC, false, false, true,
       AutocompleteInput::ALL_MATCHES));
   const AutocompleteResult& result = controller.result();
 
   // There should be three matches, one for the keyword history, one for
   // keyword provider's what-you-typed, and one for the default provider's
   // what you typed, in that order.
   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);
 
   // 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.
@@ skipping 139 matching lines @@
   fetcher->delegate()->OnURLFetchComplete(fetcher);
   fetcher = NULL;
 
   // Run till the history results complete.
   RunTillProviderDone();
 
   // Make sure the only match is 'a.com' and it doesn't have a template_url.
   AutocompleteMatch nav_match;
   EXPECT_TRUE(FindMatchWithDestination(GURL("http://a.com"), &nav_match));
   EXPECT_TRUE(nav_match.keyword.empty());
+  EXPECT_TRUE(nav_match.allowed_to_be_default_match);
   EXPECT_FALSE(FindMatchWithDestination(GURL("http://a.com/b"), &nav_match));
 }
 
 // Verifies that the most relevant suggest results are added properly.
 TEST_F(SearchProviderTest, SuggestRelevance) {
   QueryForInput(ASCIIToUTF16("a"), false, false);
 
   // Make sure the default provider's suggest service was queried.
   net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
@@ skipping 11 matching lines @@
   // Check the expected verbatim and (first 3) suggestions' relative relevances.
   AutocompleteMatch verbatim, match_a1, match_a2, match_a3, match_a4;
   EXPECT_TRUE(FindMatchWithContents(ASCIIToUTF16("a"), &verbatim));
   EXPECT_TRUE(FindMatchWithContents(ASCIIToUTF16("a1"), &match_a1));
   EXPECT_TRUE(FindMatchWithContents(ASCIIToUTF16("a2"), &match_a2));
   EXPECT_TRUE(FindMatchWithContents(ASCIIToUTF16("a3"), &match_a3));
   EXPECT_FALSE(FindMatchWithContents(ASCIIToUTF16("a4"), &match_a4));
   EXPECT_GT(verbatim.relevance, match_a1.relevance);
   EXPECT_GT(match_a1.relevance, match_a2.relevance);
   EXPECT_GT(match_a2.relevance, match_a3.relevance);
+  EXPECT_TRUE(verbatim.allowed_to_be_default_match);
+  EXPECT_TRUE(match_a1.allowed_to_be_default_match);
+  EXPECT_TRUE(match_a2.allowed_to_be_default_match);
+  EXPECT_TRUE(match_a3.allowed_to_be_default_match);
 }
 
 // Verifies that suggest results with relevance scores are added
 // properly when using the default fetcher.  When adding a new test
 // case to this test, please consider adding it to the tests in
 // KeywordFetcherSuggestRelevance below.
 TEST_F(SearchProviderTest, DefaultFetcherSuggestRelevance) {
+  struct DefaultFetcherMatch {
+    std::string contents;
+    bool allowed_to_be_default_match;
+  };
+  const DefaultFetcherMatch kEmptyMatch = { kNotApplicable, false };
   struct {
     const std::string json;
-    const std::string matches[4];
+    const DefaultFetcherMatch matches[4];
     const std::string inline_autocompletion;
   } cases[] = {
     // Ensure that suggestrelevance scores reorder matches.
     { "[\"a\",[\"b\", \"c\"],[],[],{\"google:suggestrelevance\":[1, 2]}]",
-      { "a", "c", "b", kNotApplicable }, std::string() },
+      { { "a", true }, { "c", false }, { "b", false }, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"http://b.com\", \"http://c.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:suggestrelevance\":[1, 2]}]",
-      { "a", "c.com", "b.com", kNotApplicable }, std::string() },
+      { { "a", true }, { "c.com", false }, { "b.com", 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", "b.com", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "b.com", false }, 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", "a1", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true}, { "a1", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":9998,"
                              "\"google:suggestrelevance\":[9999]}]",
-      { "a1", "a", kNotApplicable, kNotApplicable }, "1" },
+      { { "a1", true }, { "a", true }, kEmptyMatch, kEmptyMatch },
+      "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0,"
                              "\"google:suggestrelevance\":[9999]}]",
-      { "a1", kNotApplicable, kNotApplicable, kNotApplicable }, "1" },
+      { { "a1", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":-1,"
                              "\"google:suggestrelevance\":[9999]}]",
-      { "a1", "a", kNotApplicable, kNotApplicable }, "1" },
+      { { "a1", true }, { "a", true }, kEmptyMatch, kEmptyMatch },
+      "1" },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9999,"
         "\"google:suggestrelevance\":[9998]}]",
-      { "a", "a.com", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "a.com", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9998,"
         "\"google:suggestrelevance\":[9999]}]",
-      { "a.com", "a", kNotApplicable, kNotApplicable }, ".com" },
+      { { "a.com", true }, { "a", true }, kEmptyMatch, kEmptyMatch },
+      ".com" },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9999]}]",
-      { "a.com", kNotApplicable, kNotApplicable, kNotApplicable }, ".com" },
+      { { "a.com", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      ".com" },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:verbatimrelevance\":-1,"
         "\"google:suggestrelevance\":[9999]}]",
-      { "a.com", "a", kNotApplicable, kNotApplicable }, ".com" },
+      { { "a.com", true }, { "a", true }, kEmptyMatch, kEmptyMatch },
+      ".com" },
 
     // Ensure that both types of relevance scores reorder matches together.
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[9999, 9997],"
                                      "\"google:verbatimrelevance\":9998}]",
-      { "a1", "a", "a2", kNotApplicable }, "1" },
+      { { "a1", true }, { "a", true }, { "a2", true }, 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", "b", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "b", false }, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999],"
                             "\"google:verbatimrelevance\":0}]",
-      { "a", "b", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "b", false }, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999]}]",
-      { "a", "b.com", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "b.com", false }, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999],"
         "\"google:verbatimrelevance\":0}]",
-      { "a", "b.com", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "b.com", false }, 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.
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0}]",
-      { "a", "a1", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "a1", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":1}]",
-      { "a", "a1", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "a1", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[1],"
                              "\"google:verbatimrelevance\":0}]",
-      { "a", "a1", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "a1", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 2],"
                                      "\"google:verbatimrelevance\":0}]",
-      { "a", "a2", "a1", kNotApplicable }, std::string() },
+      { { "a", true }, { "a2", true }, { "a1", true }, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 3],"
       "\"google:verbatimrelevance\":2}]",
-      { "a", "a2", "a1", kNotApplicable }, std::string() },
+      { { "a", true }, { "a2", true }, { "a1", true }, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[1],"
         "\"google:verbatimrelevance\":0}]",
-      { "a", "a.com", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "a.com", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:suggestrelevance\":[1, 2],"
         "\"google:verbatimrelevance\":0}]",
-      { "a", "a2.com", "a1.com", kNotApplicable }, std::string() },
+      { { "a", true }, { "a2.com", true }, { "a1.com", true }, 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", "h", "g", "f" }, std::string() },
+      { { "a", true }, { "h", false }, { "g", false }, { "f", 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", "h.com", "g.com", "f.com" }, std::string() },
+      { { "a", true }, { "h.com", false }, { "g.com", false },
+        { "f.com", false } },
+      std::string() },
 
     // Ensure that incorrectly sized suggestion relevance lists are ignored.
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1]}]",
-      { "a", "a1", "a2", kNotApplicable }, std::string() },
+      { { "a", true }, { "a1", true }, { "a2", true }, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[9999, 1]}]",
-      { "a", "a1", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "a1", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:suggestrelevance\":[1]}]",
-      { "a", "a1.com", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "a1.com", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[\"http://a1.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
        "\"google:suggestrelevance\":[9999, 1]}]",
-      { "a", "a1.com", kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, { "a1.com", true }, 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", "a", "a1", kNotApplicable }, "2" },
+      { { "a2", true }, { "a", true }, { "a1", true }, kEmptyMatch },
+      "2" },
     { "[\"a\",[\"a\", \"a1\", \"a2\"],[],[],"
        "{\"google:suggestrelevance\":[9998, 9997, 9999],"
         "\"google:verbatimrelevance\":0}]",
-      { "a2", "a", "a1", kNotApplicable }, "2" },
+      { { "a2", true }, { "a", true }, { "a1", true }, kEmptyMatch },
+      "2" },
 
     // Ensure that verbatim is always generated without other suggestions.
     // TODO(msw): Ensure verbatimrelevance is respected (except suppression).
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":1}]",
-      { "a", kNotApplicable, kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      std::string() },
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":0}]",
-      { "a", kNotApplicable, kNotApplicable, kNotApplicable }, std::string() },
+      { { "a", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      std::string() },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(ASCIIToUTF16("a"), false, false);
     net::TestURLFetcher* fetcher =
         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());
     EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
               matches[0].inline_autocompletion) << description;
     EXPECT_GE(matches[0].relevance, 1300) << description;
 
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
-    for (; j < matches.size(); ++j)
-      EXPECT_EQ(ASCIIToUTF16(cases[i].matches[j]),
+    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;
+    }
     // Ensure that no expected matches are missing.
     for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j)
-      EXPECT_EQ(kNotApplicable, cases[i].matches[j]) <<
+      EXPECT_EQ(kNotApplicable, cases[i].matches[j].contents) <<
           "Case # " << i << " " << description;
   }
 }
+
+// This test is like DefaultFetcherSuggestRelevance above except it enables
+// the field trial that causes the omnibox to be willing to reorder matches
+// to guarantee the top result is a legal default match.  This field trial
+// causes SearchProvider to allow some constraints to be violated that it
+// wouldn't normally because the omnibox will fix the problems later.
+TEST_F(SearchProviderTest, DefaultFetcherSuggestRelevanceWithReorder) {
+  struct DefaultFetcherMatch {
+    std::string contents;
+    bool allowed_to_be_default_match;
+  };
+  const DefaultFetcherMatch kEmptyMatch = { kNotApplicable, false };
+  struct {
+    const std::string json;
+    const DefaultFetcherMatch matches[4];
+    const std::string inline_autocompletion;
+  } cases[] = {
+    // Ensure that suggestrelevance scores reorder matches.
+    { "[\"a\",[\"b\", \"c\"],[],[],{\"google:suggestrelevance\":[1, 2]}]",
+      { { "a", true }, { "c", false }, { "b", false }, kEmptyMatch },
+      std::string() },
+    { "[\"a\",[\"http://b.com\", \"http://c.com\"],[],[],"
+       "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[1, 2]}]",
+      { { "a", true }, { "c.com", false }, { "b.com", 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 }, { "b.com", false }, 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}, { "a1", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
+    { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":9998,"
+                             "\"google:suggestrelevance\":[9999]}]",
+      { { "a1", true }, { "a", true }, kEmptyMatch, kEmptyMatch },
+      "1" },
+    { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0,"
+                             "\"google:suggestrelevance\":[9999]}]",
+      { { "a1", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      "1" },
+    { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":-1,"
+                             "\"google:suggestrelevance\":[9999]}]",
+      { { "a1", true }, { "a", true }, kEmptyMatch, kEmptyMatch },
+      "1" },
+    { "[\"a\",[\"http://a.com\"],[],[],"
+       "{\"google:suggesttype\":[\"NAVIGATION\"],"
+        "\"google:verbatimrelevance\":9999,"
+        "\"google:suggestrelevance\":[9998]}]",
+      { { "a", true }, { "a.com", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
+    { "[\"a\",[\"http://a.com\"],[],[],"
+       "{\"google:suggesttype\":[\"NAVIGATION\"],"
+        "\"google:verbatimrelevance\":9998,"
+        "\"google:suggestrelevance\":[9999]}]",
+      { { "a.com", true }, { "a", true }, kEmptyMatch, kEmptyMatch },
+      ".com" },
+    { "[\"a\",[\"http://a.com\"],[],[],"
+       "{\"google:suggesttype\":[\"NAVIGATION\"],"
+        "\"google:verbatimrelevance\":0,"
+        "\"google:suggestrelevance\":[9999]}]",
+      { { "a.com", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      ".com" },
+    { "[\"a\",[\"http://a.com\"],[],[],"
+       "{\"google:suggesttype\":[\"NAVIGATION\"],"
+        "\"google:verbatimrelevance\":-1,"
+        "\"google:suggestrelevance\":[9999]}]",
+      { { "a.com", true }, { "a", true }, kEmptyMatch, kEmptyMatch },
+      ".com" },
+
+    // Ensure that both types of relevance scores reorder matches together.
+    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[9999, 9997],"
+                                     "\"google:verbatimrelevance\":9998}]",
+      { { "a1", true }, { "a", true }, { "a2", true }, kEmptyMatch },
+      "1" },
+
+    // Allow non-inlineable matches to be the highest-scoring match but,
+    // if the result set lacks a single inlineable result, abandon suggested
+    // relevance scores entirely.
+    { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999]}]",
+      { { "b", false }, { "a", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
+    { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999],"
+                            "\"google:verbatimrelevance\":0}]",
+      { { "a", true}, { "b", false }, kEmptyMatch, kEmptyMatch },
+      std::string() },
+    { "[\"a\",[\"http://b.com\"],[],[],"
+       "{\"google:suggesttype\":[\"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[9999]}]",
+      { { "b.com", false }, { "a", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
+    { "[\"a\",[\"http://b.com\"],[],[],"
+       "{\"google:suggesttype\":[\"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[9999],"
+        "\"google:verbatimrelevance\":0}]",
+      { { "a", true }, { "b.com", false }, kEmptyMatch, kEmptyMatch },
+      std::string() },
+
+    // Allow low-scoring matches.
+    { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0}]",
+      { { "a1", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      "1" },
+    { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":1}]",
+      { { "a1", true }, { "a", true }, kEmptyMatch, kEmptyMatch },
+      "1" },
+    { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[1],"
+                             "\"google:verbatimrelevance\":0}]",
+      { { "a1", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      "1" },
+    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 2],"
+                                     "\"google:verbatimrelevance\":0}]",
+      { { "a2", true }, { "a1", true }, kEmptyMatch, kEmptyMatch },
+      "2" },
+    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 3],"
+      "\"google:verbatimrelevance\":2}]",
+      { { "a2", true }, { "a", true }, { "a1", true }, kEmptyMatch },
+      "2" },
+    { "[\"a\",[\"http://a.com\"],[],[],"
+       "{\"google:suggesttype\":[\"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[1],"
+        "\"google:verbatimrelevance\":0}]",
+      { { "a.com", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      ".com" },
+    { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
+       "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[1, 2],"
+        "\"google:verbatimrelevance\":0}]",
+      { { "a2.com", true }, { "a1.com", true }, kEmptyMatch, kEmptyMatch },
+      "2.com" },
+
+    // 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 }, { "h", false }, { "g", false }, { "f", 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 }, { "h.com", false }, { "g.com", false },
+        { "f.com", false } },
+      std::string() },
+
+    // Ensure that incorrectly sized suggestion relevance lists are ignored.
+    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1]}]",
+      { { "a", true }, { "a1", true }, { "a2", true }, kEmptyMatch },
+      std::string() },
+    { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[9999, 1]}]",
+      { { "a", true }, { "a1", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
+    { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
+       "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[1]}]",
+      { { "a", true }, { "a1.com", true }, kEmptyMatch, kEmptyMatch },
+      std::string() },
+    { "[\"a\",[\"http://a1.com\"],[],[],"
+       "{\"google:suggesttype\":[\"NAVIGATION\"],"
+       "\"google:suggestrelevance\":[9999, 1]}]",
+      { { "a", true }, { "a1.com", true }, 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 }, { "a", true }, { "a1", true }, kEmptyMatch },
+      "2" },
+    { "[\"a\",[\"a\", \"a1\", \"a2\"],[],[],"
+       "{\"google:suggestrelevance\":[9998, 9997, 9999],"
+        "\"google:verbatimrelevance\":0}]",
+      { { "a2", true }, { "a", true }, { "a1", true }, kEmptyMatch },
+      "2" },
+
+    // Ensure that verbatim is always generated without other suggestions.
+    // TODO(msw): Ensure verbatimrelevance is respected (except suppression).
+    { "[\"a\",[],[],[],{\"google:verbatimrelevance\":1}]",
+      { { "a", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      std::string() },
+    { "[\"a\",[],[],[],{\"google:verbatimrelevance\":0}]",
+      { { "a", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch },
+      std::string() },
+  };
+
+  // Must be the same as kBundledExperimentFieldTrialName
+  // defined in omnibox_field_trial.cc.
+  const std::string kTrialName = "OmniboxBundledExperimentV1";
+  // Must be the same as kReorderForLegalDefaultMatchRule defined in
+  // omnibox_field_trial.cc.
+  const std::string kRuleName = "ReorderForLegalDefaultMatch";
+  std::map<std::string, std::string> params;
+  params[kRuleName + ":*"] = "ReorderForLegalDefaultMatch";
+  ASSERT_TRUE(chrome_variations::AssociateVariationParams(
+      kTrialName, "A", params));
+  base::FieldTrialList::CreateFieldTrial(kTrialName, "A");
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
+    QueryForInput(ASCIIToUTF16("a"), false, false);
+    net::TestURLFetcher* fetcher =
+        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());
+    EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
+              matches[0].inline_autocompletion) << description;
+
+    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;
+    }
+    // Ensure that no expected matches are missing.
+    for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j)
+      EXPECT_EQ(kNotApplicable, cases[i].matches[j].contents) <<
+          "Case # " << i << " " << description;
+  }
+}
 
 // Verifies that suggest results with relevance scores are added
 // properly when using the keyword fetcher.  This is similar to the
 // test DefaultFetcherSuggestRelevance above but this uses inputs that
 // trigger keyword suggestions (i.e., "k a" rather than "a") and has
 // different expectations (because now the results are a mix of
 // keyword suggestions and default provider suggestions).  When a new
 // test is added to this TEST_F, please consider if it would be
 // appropriate to add to DefaultFetcherSuggestRelevance as well.
 TEST_F(SearchProviderTest, KeywordFetcherSuggestRelevance) {
+  struct KeywordFetcherMatch {
+    std::string contents;
+    bool from_keyword;
+    bool allowed_to_be_default_match;
+  };
+  const KeywordFetcherMatch kEmptyMatch = { kNotApplicable, false, false };
   struct {
     const std::string json;
-    const struct {
-      const std::string contents;
-      const bool from_keyword;
-    } matches[5];
+    const KeywordFetcherMatch matches[5];
     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 },
-        { "k a", false },
-        { "c", true },
-        { "b", true },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "k a", false, true },
+        { "c", true, false },
+        { "b", true, false },
+        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.
     { "[\"a\",[\"http://b.com\", \"http://c.com\", \"d\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
        "\"google:suggestrelevance\":[1301, 1302, 1303]}]",
-      { { "a", true },
-        { "d", true },
-        { "c.com", false },
-        { "b.com", false },
-        { "k a", false }, },
+      { { "a", true, true },
+        { "d", true, false },
+        { "c.com", false, false },
+        { "b.com", false, false },
+        { "k a", false, true }, },
       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 },
-        { "b.com", false },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "b.com", false, false },
+        { "k a", false, true },
+        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 },
-        { "a1", true },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a1", true, true },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":9998,"
                              "\"google:suggestrelevance\":[9999]}]",
-      { { "a1", true },
-        { "a", true },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a1", true, true },
+        { "a", true, true },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch },
       "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0,"
                              "\"google:suggestrelevance\":[9999]}]",
-      { { "a1", true },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a1", true, true },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch,
+        kEmptyMatch },
       "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":-1,"
                              "\"google:suggestrelevance\":[9999]}]",
-      { { "a1", true },
-        { "a", true },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a1", true, true },
+        { "a", true, true },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch },
       "1" },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9999,"
         "\"google:suggestrelevance\":[9998]}]",
-      { { "a", true },
-        { "a.com", false },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a.com", false, true },
+        { "k a", false, true },
+        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 },
-        { "a", true },
-        { "a2", true },
-        { "k a", false },
-        { kNotApplicable, false } },
+      { { "a1", true, true },
+        { "a", true, true },
+        { "a2", true, true },
+        { "k a", false, true },
+        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 },
-        { "b", true },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "b", true, false },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999],"
                             "\"google:verbatimrelevance\":0}]",
-      { { "a", true },
-        { "b", true },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "b", true, false },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999]}]",
-      { { "a", true },
-        { "b.com", false },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "b.com", false, false },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999],"
         "\"google:verbatimrelevance\":0}]",
-      { { "a", true },
-        { "b.com", false },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "b.com", false, false },
+        { "k a", false, true },
+        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 },
-        { "a1", true },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a1", true, true },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":1}]",
-      { { "a", true },
-        { "a1", true },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a1", true, true },
+        { "k a", false, true },
+        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 },
-        { "k a", false },
-        { "a1", true },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "k a", false, true },
+        { "a1", true, true },
+        kEmptyMatch,
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 2],"
                                      "\"google:verbatimrelevance\":0}]",
-      { { "a", true },
-        { "k a", false },
-        { "a2", true },
-        { "a1", true },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "k a", false, true },
+        { "a2", true, true },
+        { "a1", true, true },
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 3],"
       "\"google:verbatimrelevance\":2}]",
-      { { "a", true },
-        { "k a", false },
-        { "a2", true },
-        { "a1", true },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "k a", false, true },
+        { "a2", true, true },
+        { "a1", true, true },
+        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 },
-        { "k a", false },
-        { "h", true },
-        { "g", true },
-        { "f", true } },
+      { { "a", true, true },
+        { "k a", false, true },
+        { "h", true, false },
+        { "g", true, false },
+        { "f", 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 },
-        { "k a", false },
-        { "h.com", false },
-        { "g.com", false },
-        { "f.com", false } },
+      { { "a", true, true },
+        { "k a", false, true },
+        { "h.com", false, false },
+        { "g.com", false, false },
+        { "f.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 },
-        { "a1", true },
-        { "a2", true },
-        { "k a", false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a1", true, true },
+        { "a2", true, true },
+        { "k a", false, true },
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[9999, 1]}]",
-      { { "a", true },
-        { "a1", true },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a1", true, true },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch },
       std::string() },
     // In this case, ignored 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 },
-        { "a1.com", false },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a1.com", false, true },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
        "\"google:suggestrelevance\":[9999, 1]}]",
-      { { "a", true },
-        { "a1.com", false },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a1.com", false, true },
+        { "k a", false, true },
+        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 },
-        { "a", true },
-        { "a1", true },
-        { "k a", false },
-        { kNotApplicable, false } },
+      { { "a2", true, true },
+        { "a", true, true },
+        { "a1", true, true },
+        { "k a", false, true },
+        kEmptyMatch },
       "2" },
     { "[\"a\",[\"a\", \"a1\", \"a2\"],[],[],"
        "{\"google:suggestrelevance\":[9998, 9997, 9999],"
         "\"google:verbatimrelevance\":0}]",
-      { { "a2", true },
-        { "a", true },
-        { "a1", true },
-        { "k a", false },
-        { kNotApplicable, false } },
+      { { "a2", true, true },
+        { "a", true, true },
+        { "a1", true, true },
+        { "k a", false, true },
+        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 },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch,
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":0}]",
-      { { "a", true },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "k a", false, true },
+        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 },
-        { "a2.com", false },
-        { "a1.com", false },
-        { "k a", false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a2.com", false, true },
+        { "a1.com", false, true },
+        { "k a", false, true },
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9999, 9998]}]",
-      { { "a", true },
-        { "a1.com", false },
-        { "a2.com", false },
-        { "k a", false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a1.com", false, true },
+        { "a2.com", false, true },
+        { "k a", false, true },
+        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 },
-        { "a2.com", false },
-        { "a1.com", false },
-        { "a3", true },
-        { "k a", false } },
+      { { "a", true, true },
+        { "a2.com", false, true },
+        { "a1.com", false, true },
+        { "a3", true, true },
+        { "k a", false, true } },
       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 },
-        { "a1.com", false },
-        { "a2.com", false },
-        { "a3", true },
-        { "k a", false } },
+      { { "a", true, true },
+        { "a1.com", false, true },
+        { "a2.com", false, true },
+        { "a3", true, true },
+        { "k a", false, true } },
       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 },
-        { "a2.com", false },
-        { "a1.com", false },
-        { "a", true },
-        { "k a", false } },
+      { { "a3", true, true },
+        { "a2.com", false, true },
+        { "a1.com", false, true },
+        { "a", true, true },
+        { "k a", false, true } },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9999, 9998, 9997]}]",
-      { { "a3", true },
-        { "a1.com", false },
-        { "a2.com", false },
-        { "a", true },
-        { "k a", false } },
+      { { "a3", true, true },
+        { "a1.com", false, true },
+        { "a2.com", false, true },
+        { "a", true, true },
+        { "k a", false, true } },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9998, 9999, 9997]}]",
-      { { "a3", true },
-        { "a2.com", false },
-        { "a1.com", false },
-        { "k a", false },
-        { kNotApplicable, false } },
+      { { "a3", true, true },
+        { "a2.com", false, true },
+        { "a1.com", false, true },
+        { "k a", false, true },
+        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 },
-        { "a1.com", false },
-        { "a2.com", false },
-        { "k a", false },
-        { kNotApplicable, false } },
+      { { "a3", true, true },
+        { "a1.com", false, true },
+        { "a2.com", false, true },
+        { "k a", false, true },
+        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 },
-        { "a2.com", false },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a2.com", false, true },
+        { "k a", false, true },
+        kEmptyMatch,
+        kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9999, 9998]}]",
-      { { "a", true },
-        { "a1.com", false },
-        { "k a", false },
-        { kNotApplicable, false },
-        { kNotApplicable, false } },
+      { { "a", true, true },
+        { "a1.com", false, true },
+        { "k a", false, true },
+        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 },
-        { "a2.com", false },
-        { "a1.com", false },
-        { "a", true },
-        { "k a", false } },
+      { { "a3", true, true },
+        { "a2.com", false, true },
+        { "a1.com", false, true },
+        { "a", true, true },
+        { "k a", false, true } },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9997, 9999]}]",
-      { { "a3", true },
-        { "a1.com", false },
-        { "a2.com", false },
-        { "a", true },
-        { "k a", false } },
+      { { "a3", true, true },
+        { "a1.com", false, true },
+        { "a2.com", false, true },
+        { "a", true, true },
+        { "k a", false, true } },
       "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(
             SearchProvider::kDefaultProviderURLFetcherID);
@@ skipping 21 matching lines @@
               matches[0].inline_autocompletion) << description;
     EXPECT_GE(matches[0].relevance, 1300) << description;
 
     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,
+                matches[j].allowed_to_be_default_match) << description;
     }
     // Ensure that no expected matches are missing.
     for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j)
       EXPECT_EQ(kNotApplicable, cases[i].matches[j].contents) <<
           "Case # " << i << " " << description;
   }
 }
 
 TEST_F(SearchProviderTest, LocalAndRemoteRelevances) {
   // Enable Instant Extended in order to allow an increased number of
@@ skipping 97 matching lines @@
                 matches[j].contents) << description;
     // Ensure that no expected matches are missing.
     for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j)
       EXPECT_EQ(kNotApplicable, cases[i].matches[j]) <<
           "Case # " << i << " " << description;
   }
 }
 
 // Verifies suggest relevance behavior for URL input.
 TEST_F(SearchProviderTest, DefaultProviderSuggestRelevanceScoringUrlInput) {
+  struct DefaultFetcherUrlInputMatch {
+    const std::string match_contents;
+    AutocompleteMatch::Type match_type;
+    bool allowed_to_be_default_match;
+  };
+  const DefaultFetcherUrlInputMatch kEmptyMatch =
+      { kNotApplicable, AutocompleteMatchType::NUM_TYPES, false };
   struct {
     const std::string input;
     const std::string json;
-    const std::string match_contents[4];
-    const AutocompleteMatch::Type match_types[4];
+    const DefaultFetcherUrlInputMatch output[4];
   } cases[] = {
     // Ensure topmost NAVIGATION matches are allowed for URL input.
     { "a.com", "[\"a.com\",[\"http://a.com/a\"],[],[],"
                 "{\"google:suggesttype\":[\"NAVIGATION\"],"
                  "\"google:suggestrelevance\":[9999]}]",
-      { "a.com/a", "a.com", kNotApplicable, kNotApplicable },
-      { AutocompleteMatchType::NAVSUGGEST,
-        AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
-        AutocompleteMatchType::NUM_TYPES,
-        AutocompleteMatchType::NUM_TYPES } },
+      { { "a.com/a", AutocompleteMatchType::NAVSUGGEST, true },
+        { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+        kEmptyMatch, kEmptyMatch } },
 
     // Ensure topmost SUGGEST matches are not allowed for URL input.
     // SearchProvider disregards search and verbatim suggested relevances.
     { "a.com", "[\"a.com\",[\"a.com info\"],[],[],"
                 "{\"google:suggestrelevance\":[9999]}]",
-      { "a.com", "a.com info", kNotApplicable, kNotApplicable },
-      { AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
-        AutocompleteMatchType::SEARCH_SUGGEST,
-        AutocompleteMatchType::NUM_TYPES, AutocompleteMatchType::NUM_TYPES } },
+      { { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+        { "a.com info", AutocompleteMatchType::SEARCH_SUGGEST, true },
+        kEmptyMatch,
+        kEmptyMatch } },
     { "a.com", "[\"a.com\",[\"a.com/a\"],[],[],"
                 "{\"google:suggestrelevance\":[9999]}]",
-      { "a.com", "a.com/a", kNotApplicable, kNotApplicable },
-      { AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
-        AutocompleteMatchType::SEARCH_SUGGEST,
-        AutocompleteMatchType::NUM_TYPES, AutocompleteMatchType::NUM_TYPES } },
+      { { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+        { "a.com/a", AutocompleteMatchType::SEARCH_SUGGEST, true },
+        kEmptyMatch, kEmptyMatch } },
 
     // Ensure the fallback mechanism allows inlinable NAVIGATION matches.
     { "a.com", "[\"a.com\",[\"a.com/a\", \"http://a.com/b\"],[],[],"
                 "{\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\"],"
                  "\"google:suggestrelevance\":[9999, 9998]}]",
-      { "a.com/b", "a.com", "a.com/a", kNotApplicable },
-      { AutocompleteMatchType::NAVSUGGEST,
-        AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
-        AutocompleteMatchType::SEARCH_SUGGEST,
-        AutocompleteMatchType::NUM_TYPES } },
+      { { "a.com/b", AutocompleteMatchType::NAVSUGGEST, true },
+        { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+        { "a.com/a", AutocompleteMatchType::SEARCH_SUGGEST, true },
+        kEmptyMatch } },
     { "a.com", "[\"a.com\",[\"a.com/a\", \"http://a.com/b\"],[],[],"
                 "{\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\"],"
                  "\"google:suggestrelevance\":[9998, 9997],"
                  "\"google:verbatimrelevance\":9999}]",
-      { "a.com/b", "a.com", "a.com/a", kNotApplicable },
-      { AutocompleteMatchType::NAVSUGGEST,
-        AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
-        AutocompleteMatchType::SEARCH_SUGGEST,
-        AutocompleteMatchType::NUM_TYPES } },
+      { { "a.com/b", AutocompleteMatchType::NAVSUGGEST, true },
+        { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+        { "a.com/a", AutocompleteMatchType::SEARCH_SUGGEST, true },
+        kEmptyMatch } },
 
     // Ensure the fallback mechanism disallows non-inlinable NAVIGATION matches.
     { "a.com", "[\"a.com\",[\"a.com/a\", \"http://abc.com\"],[],[],"
                 "{\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\"],"
       "\"google:suggestrelevance\":[9999, 9998]}]",
-      { "a.com", "abc.com", "a.com/a", kNotApplicable },
-      { AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
-        AutocompleteMatchType::NAVSUGGEST,
-        AutocompleteMatchType::SEARCH_SUGGEST,
-        AutocompleteMatchType::NUM_TYPES } },
+      { { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+        { "abc.com", AutocompleteMatchType::NAVSUGGEST, false },
+        { "a.com/a", AutocompleteMatchType::SEARCH_SUGGEST, true },
+        kEmptyMatch } },
     { "a.com", "[\"a.com\",[\"a.com/a\", \"http://abc.com\"],[],[],"
                 "{\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\"],"
                  "\"google:suggestrelevance\":[9998, 9997],"
                  "\"google:verbatimrelevance\":9999}]",
-      { "a.com", "abc.com", "a.com/a", kNotApplicable },
-      { AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
-        AutocompleteMatchType::NAVSUGGEST,
-        AutocompleteMatchType::SEARCH_SUGGEST,
-        AutocompleteMatchType::NUM_TYPES } },
+      { { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+        { "abc.com", AutocompleteMatchType::NAVSUGGEST, false },
+        { "a.com/a", AutocompleteMatchType::SEARCH_SUGGEST, true },
+        kEmptyMatch } },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(ASCIIToUTF16(cases[i].input), false, false);
     net::TestURLFetcher* fetcher =
         test_factory_.GetFetcherByID(
             SearchProvider::kDefaultProviderURLFetcherID);
     ASSERT_TRUE(fetcher);
     fetcher->set_response_code(200);
     fetcher->SetResponseString(cases[i].json);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunTillProviderDone();
 
     size_t j = 0;
     const ACMatches& matches = provider_->matches();
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
-      EXPECT_EQ(ASCIIToUTF16(cases[i].match_contents[j]), matches[j].contents);
-      EXPECT_EQ(cases[i].match_types[j], matches[j].type);
+      EXPECT_EQ(ASCIIToUTF16(cases[i].output[j].match_contents),
+                matches[j].contents);
+      EXPECT_EQ(cases[i].output[j].match_type, matches[j].type);
+      EXPECT_EQ(cases[i].output[j].allowed_to_be_default_match,
+                matches[j].allowed_to_be_default_match);
     }
     // Ensure that no expected matches are missing.
-    for (; j < ARRAYSIZE_UNSAFE(cases[i].match_contents); ++j) {
-      EXPECT_EQ(kNotApplicable, cases[i].match_contents[j]);
-      EXPECT_EQ(AutocompleteMatchType::NUM_TYPES, cases[i].match_types[j]);
+    for (; j < ARRAYSIZE_UNSAFE(cases[i].output); ++j) {
+      EXPECT_EQ(kNotApplicable, cases[i].output[j].match_contents);
+      EXPECT_EQ(AutocompleteMatchType::NUM_TYPES,
+                cases[i].output[j].match_type);
+      EXPECT_FALSE(cases[i].output[j].allowed_to_be_default_match);
     }
   }
 }
 
 // A basic test that verifies the field trial triggered parsing logic.
 TEST_F(SearchProviderTest, FieldTrialTriggeredParsing) {
   QueryForInput(ASCIIToUTF16("foo"), false, false);
 
   // Make sure the default providers suggest service was queried.
   net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
@@ skipping 35 matching lines @@
 
 // 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;
+    const bool allowed_to_be_default_match;
   } cases[] = {
     // Do not inline matches that do not contain the input; trim http as needed.
     { "x",                    "http://www.abc.com",
-      "www.abc.com",  std::string() },
+                                     "www.abc.com",  std::string(), false },
     { "https:",               "http://www.abc.com",
-                                     "www.abc.com",  std::string() },
+                                     "www.abc.com",  std::string(), false },
     { "abc.com/",             "http://www.abc.com",
-                                     "www.abc.com",  std::string() },
+                                     "www.abc.com",  std::string(), false },
     { "http://www.abc.com/a", "http://www.abc.com",
-                              "http://www.abc.com",  std::string() },
+                              "http://www.abc.com",  std::string(), false },
     { "http://www.abc.com",   "https://www.abc.com",
-                              "https://www.abc.com", std::string() },
+                              "https://www.abc.com", std::string(), false },
     { "http://abc.com",       "ftp://abc.com",
-                              "ftp://abc.com",       std::string() },
+                              "ftp://abc.com",       std::string(), false },
     { "https://www.abc.com",  "http://www.abc.com",
-                                     "www.abc.com",  std::string() },
+                                     "www.abc.com",  std::string(), false },
     { "ftp://abc.com",        "http://abc.com",
-                                     "abc.com",      std::string() },
+                                     "abc.com",      std::string(), false },
 
     // Do not inline matches with invalid input prefixes; trim http as needed.
     { "ttp",                  "http://www.abc.com",
-                                     "www.abc.com", std::string() },
+                                     "www.abc.com", std::string(), false },
     { "://w",                 "http://www.abc.com",
-                                     "www.abc.com", std::string() },
+                                     "www.abc.com", std::string(), false },
     { "ww.",                  "http://www.abc.com",
-                                     "www.abc.com", std::string() },
+                                     "www.abc.com", std::string(), false },
     { ".ab",                  "http://www.abc.com",
-                                     "www.abc.com", std::string() },
+                                     "www.abc.com", std::string(), false },
     { "bc",                   "http://www.abc.com",
-                                     "www.abc.com", std::string() },
+                                     "www.abc.com", std::string(), false },
     { ".com",                 "http://www.abc.com",
-                                     "www.abc.com", std::string() },
+                                     "www.abc.com", std::string(), false },
 
     // Do not inline matches that omit input domain labels; trim http as needed.
     { "www.a",                "http://a.com",
-                                     "a.com",       std::string() },
+                                     "a.com",       std::string(), false },
     { "http://www.a",         "http://a.com",
-                              "http://a.com",       std::string() },
+                              "http://a.com",       std::string(), false },
     { "www.a",                "ftp://a.com",
-                              "ftp://a.com",        std::string() },
+                              "ftp://a.com",        std::string(), false },
     { "ftp://www.a",          "ftp://a.com",
-                              "ftp://a.com",        std::string() },
+                              "ftp://a.com",        std::string(), false },
 
     // Input matching but with nothing to inline will not yield an offset.
     { "abc.com",              "http://www.abc.com",
-                                     "www.abc.com", std::string() },
+                                     "www.abc.com", std::string(), false },
     { "http://www.abc.com",   "http://www.abc.com",
-                              "http://www.abc.com", std::string() },
+                              "http://www.abc.com", std::string(), false },
 
     // Inline matches when the input is a leading substring of the scheme.
     { "h",                    "http://www.abc.com",
-                              "http://www.abc.com", "ttp://www.abc.com" },
+                              "http://www.abc.com", "ttp://www.abc.com", true },
     { "http",                 "http://www.abc.com",
-                              "http://www.abc.com", "://www.abc.com" },
+                              "http://www.abc.com", "://www.abc.com", true },
 
     // Inline matches when the input is a leading substring of the full URL.
     { "http:",                "http://www.abc.com",
-                              "http://www.abc.com", "//www.abc.com" },
+                              "http://www.abc.com", "//www.abc.com", true },
     { "http://w",             "http://www.abc.com",
-                              "http://www.abc.com", "ww.abc.com" },
+                              "http://www.abc.com", "ww.abc.com", true },
     { "http://www.",          "http://www.abc.com",
-                              "http://www.abc.com", "abc.com" },
+                              "http://www.abc.com", "abc.com", true },
     { "http://www.ab",        "http://www.abc.com",
-                              "http://www.abc.com", "c.com" },
+                              "http://www.abc.com", "c.com", true },
     { "http://www.abc.com/p", "http://www.abc.com/path/file.htm?q=x#foo",
                               "http://www.abc.com/path/file.htm?q=x#foo",
-                                                  "ath/file.htm?q=x#foo" },
+                                                  "ath/file.htm?q=x#foo",
+                              true },
     { "http://abc.com/p",     "http://abc.com/path/file.htm?q=x#foo",
                               "http://abc.com/path/file.htm?q=x#foo",
-                                              "ath/file.htm?q=x#foo"},
+                                              "ath/file.htm?q=x#foo", true},
 
     // Inline matches with valid URLPrefixes; only trim "http://".
     { "w",                    "http://www.abc.com",
-                                     "www.abc.com", "ww.abc.com" },
+                                     "www.abc.com", "ww.abc.com", true },
     { "www.a",                "http://www.abc.com",
-                                     "www.abc.com", "bc.com" },
+                                     "www.abc.com", "bc.com", true },
     { "abc",                  "http://www.abc.com",
-                                     "www.abc.com", ".com" },
+                                     "www.abc.com", ".com", true },
     { "abc.c",                "http://www.abc.com",
-                                     "www.abc.com", "om" },
+                                     "www.abc.com", "om", true },
     { "abc.com/p",            "http://www.abc.com/path/file.htm?q=x#foo",
                                      "www.abc.com/path/file.htm?q=x#foo",
-                                                  "ath/file.htm?q=x#foo" },
+                                                  "ath/file.htm?q=x#foo",
+                              true },
     { "abc.com/p",            "http://abc.com/path/file.htm?q=x#foo",
                                      "abc.com/path/file.htm?q=x#foo",
-                                              "ath/file.htm?q=x#foo" },
+                                              "ath/file.htm?q=x#foo", true },
 
     // Inline matches using the maximal URLPrefix components.
     { "h",                    "http://help.com",
-                                     "help.com", "elp.com" },
+                                     "help.com", "elp.com", true },
     { "http",                 "http://http.com",
-                                     "http.com", ".com" },
+                                     "http.com", ".com", true },
     { "h",                    "http://www.help.com",
-                                     "www.help.com", "elp.com" },
+                                     "www.help.com", "elp.com", true },
     { "http",                 "http://www.http.com",
-                                     "www.http.com", ".com" },
+                                     "www.http.com", ".com", true },
     { "w",                    "http://www.www.com",
-                                     "www.www.com",  "ww.com" },
+                                     "www.www.com",  "ww.com", true },
 
     // Test similar behavior for the ftp and https schemes.
     { "ftp://www.ab",         "ftp://www.abc.com/path/file.htm?q=x#foo",
                               "ftp://www.abc.com/path/file.htm?q=x#foo",
-                                          "c.com/path/file.htm?q=x#foo" },
+                                          "c.com/path/file.htm?q=x#foo", true },
     { "www.ab",               "ftp://www.abc.com/path/file.htm?q=x#foo",
                               "ftp://www.abc.com/path/file.htm?q=x#foo",
-                                          "c.com/path/file.htm?q=x#foo" },
+                                          "c.com/path/file.htm?q=x#foo", true },
     { "ab",                   "ftp://www.abc.com/path/file.htm?q=x#foo",
                               "ftp://www.abc.com/path/file.htm?q=x#foo",
-                                          "c.com/path/file.htm?q=x#foo" },
+                                          "c.com/path/file.htm?q=x#foo", true },
     { "ab",                   "ftp://abc.com/path/file.htm?q=x#foo",
                               "ftp://abc.com/path/file.htm?q=x#foo",
-                                      "c.com/path/file.htm?q=x#foo" },
+                                      "c.com/path/file.htm?q=x#foo", true },
     { "https://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" },
+                                            "c.com/path/file.htm?q=x#foo",
+                              true },
     { "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" },
+                                            "c.com/path/file.htm?q=x#foo",
+                              true },
     { "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" },
+                                            "c.com/path/file.htm?q=x#foo",
+                              true },
     { "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"},
+                                        "c.com/path/file.htm?q=x#foo",
+                              true },
 
     // Forced query input should inline and retain the "?" prefix.
     { "?http://www.ab",       "http://www.abc.com",
-                             "?http://www.abc.com", "c.com" },
+                             "?http://www.abc.com", "c.com", true },
     { "?www.ab",              "http://www.abc.com",
-                                    "?www.abc.com", "c.com" },
+                                    "?www.abc.com", "c.com", true },
     { "?ab",                  "http://www.abc.com",
-                                    "?www.abc.com", "c.com" },
+                                    "?www.abc.com", "c.com", true },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(ASCIIToUTF16(cases[i].input), false, false);
     AutocompleteMatch match(
         provider_->NavigationToMatch(SearchProvider::NavigationResult(
             *provider_.get(), GURL(cases[i].url), string16(), false, 0,
             false)));
     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,
+              match.allowed_to_be_default_match);
   }
 }
 
 // Verifies that "http://" is not trimmed for input that is a leading substring.
 TEST_F(SearchProviderTest, NavigationInlineSchemeSubstring) {
   const string16 input(ASCIIToUTF16("ht"));
   const string16 url(ASCIIToUTF16("http://a.com"));
   const SearchProvider::NavigationResult result(
       *provider_.get(), GURL(url), string16(), false, 0, 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 offset and 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_TRUE(match_prevent.inline_autocompletion.empty());
-  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);
   AutocompleteMatch match(
       provider_->NavigationToMatch(SearchProvider::NavigationResult(
           *provider_.get(), GURL("http://www.wow.com"), string16(), false, 0,
           false)));
   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);
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL,
             match.contents_class[0].style);
   EXPECT_EQ(4U, match.contents_class[1].offset);
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL |
@@ skipping 184 matching lines @@
       } else {
         ASSERT_NE(sug_end, sug_it) << "Failed to find " << suggestion;
         EXPECT_EQ(ASCIIToUTF16(suggestion), sug_it->suggestion());
         ++sug_it;
       }
     }
     EXPECT_EQ(sug_end, sug_it);
     EXPECT_EQ(nav_end, nav_it);
   }
 }