Omnibox: Prevent Asynchronous Suggestions from Changing Default Match

chrome/browser/autocomplete/search_provider_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/omnibox/search_provider.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
@@ skipping 124 matching lines @@
     const bool allowed_to_be_default_match;
     const base::string16 fill_into_edit;
   };
 
   struct TestData {
     const base::string16 input;
     const size_t num_results;
     const ResultInfo output[3];
   };
 
+  struct ExpectedMatch {
+    std::string contents;
+    bool allowed_to_be_default_match;
+  };
+
   SearchProviderTest()
       : default_t_url_(NULL),
         term1_(ASCIIToUTF16("term1")),
         keyword_t_url_(NULL),
         keyword_term_(ASCIIToUTF16("keyword")),
         run_loop_(NULL) {
     ResetFieldTrialList();
   }
 
   // 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();
   scoped_ptr<base::FieldTrialList> field_trial_list_;
 
-  // Default value used for testing.
+  // Default values used for testing.
   static const std::string kNotApplicable;
+  static const ExpectedMatch kEmptyExpectedMatch;
 
   // Adds a search for |term|, using the engine |t_url| to the history, and
   // returns the URL for that search.
   GURL AddSearchToHistory(TemplateURL* t_url, base::string16 term, int visit_count);
 
   // Looks for a match in |provider_| with |contents| equal to |contents|.
   // Sets |match| to it if found.  Returns whether |match| was set.
   bool FindMatchWithContents(const base::string16& contents,
                              AutocompleteMatch* match);
 
@@ skipping 12 matching lines @@
   // Invokes Start on provider_, then runs all pending tasks.
   void QueryForInput(const base::string16& text,
                      bool prevent_inline_autocomplete,
                      bool prefer_keyword);
 
   // 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 base::string16& text,
                                    AutocompleteMatch* wyt_match);
 
+  // Calls QueryForInput(), sets the JSON responses for the default and keyword
+  // fetchers, and waits until the responses have been returned and the matches
+  // returned.  Use empty responses for each fetcher that shouldn't be set up /
+  // configured.
+  void QueryForInputAndWaitForFetcherResponses(
+      const base::string16& text,
+      const bool prefer_keyword,
+      const std::string& default_fetcher_response,
+      const std::string& keyword_fetcher_response);
+
   // Notifies the URLFetcher for the suggest query corresponding to the default
   // search provider that it's done.
   // Be sure and wrap calls to this in ASSERT_NO_FATAL_FAILURE.
   void FinishDefaultSuggestQuery();
 
   // Runs SearchProvider on |input|, for which the suggest server replies
   // with |json|, and expects that the resulting matches' contents equals
   // that in |matches|.  An empty entry in |matches| means no match should
   // be returned in that position.  Reports any errors with a message that
   // includes |error_description|.
   void ForcedQueryTestHelper(const std::string& input,
                              const std::string& json,
                              const std::string matches[3],
                              const std::string& error_description);
 
+  // Verifies that |matches| and |expected_matches| agree on the first
+  // |num_expected_matches|, displaying an error message that includes
+  // |description| for any disagreement.
+  void CheckMatches(const std::string& description,
+                    const size_t num_expected_matches,
+                    const ExpectedMatch expected_matches[],
+                    const ACMatches& matches);
+
   void ResetFieldTrialList();
 
   // Create a field trial, with ZeroSuggest activation based on |enabled|.
   base::FieldTrial* CreateZeroSuggestFieldTrial(bool enabled);
 
   void ClearAllResults();
 
   // See description above class for details of these fields.
   TemplateURL* default_t_url_;
   const base::string16 term1_;
@@ skipping 14 matching lines @@
   scoped_refptr<SearchProviderForTest> provider_;
 
   // If non-NULL, OnProviderUpdate quits the current |run_loop_|.
   base::RunLoop* run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SearchProviderTest);
 };
 
 // static
 const std::string SearchProviderTest::kNotApplicable = "Not Applicable";
+const SearchProviderTest::ExpectedMatch
+    SearchProviderTest::kEmptyExpectedMatch = { kNotApplicable, false };
 
 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 54 matching lines @@
                                  bool prefer_keyword) {
   ACMatches matches;
   for (int i = 0; i < num_cases; ++i) {
     AutocompleteInput input(cases[i].input, base::string16::npos,
                             base::string16(), GURL(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             prefer_keyword, true, true,
                             ChromeAutocompleteSchemeClassifier(&profile_));
     provider_->Start(input, false);
     matches = provider_->matches();
-    base::string16 diagnostic_details =
+    SCOPED_TRACE(
         ASCIIToUTF16("Input was: ") +
         cases[i].input +
         ASCIIToUTF16("; prefer_keyword was: ") +
-        (prefer_keyword ? ASCIIToUTF16("true") : ASCIIToUTF16("false"));
-    EXPECT_EQ(cases[i].num_results, matches.size()) << diagnostic_details;
+        (prefer_keyword ? ASCIIToUTF16("true") : ASCIIToUTF16("false")));
+    EXPECT_EQ(cases[i].num_results, matches.size());
     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].gurl, matches[j].destination_url);
+        EXPECT_EQ(cases[i].output[j].result_type, matches[j].type);
         EXPECT_EQ(cases[i].output[j].fill_into_edit,
-                  matches[j].fill_into_edit) << diagnostic_details;
+                  matches[j].fill_into_edit);
         EXPECT_EQ(cases[i].output[j].allowed_to_be_default_match,
-                  matches[j].allowed_to_be_default_match) << diagnostic_details;
+                  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 34 matching lines @@
   ASSERT_GE(provider_->matches().size(), 1u);
   EXPECT_TRUE(FindMatchWithDestination(
       GURL(default_t_url_->url_ref().ReplaceSearchTerms(
           TemplateURLRef::SearchTermsArgs(base::CollapseWhitespace(
               text, false)),
           TemplateURLServiceFactory::GetForProfile(
               &profile_)->search_terms_data())),
       wyt_match));
 }
 
+void SearchProviderTest::QueryForInputAndWaitForFetcherResponses(
+    const base::string16& text,
+    const bool prefer_keyword,
+    const std::string& default_fetcher_response,
+    const std::string& keyword_fetcher_response) {
+  QueryForInput(text, false, prefer_keyword);
+  if (!default_fetcher_response.empty()) {
+    net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
+        SearchProvider::kDefaultProviderURLFetcherID);
+    ASSERT_TRUE(fetcher);
+    fetcher->set_response_code(200);
+    fetcher->SetResponseString(default_fetcher_response);
+    fetcher->delegate()->OnURLFetchComplete(fetcher);
+  }
+  if (!keyword_fetcher_response.empty()) {
+    net::TestURLFetcher* keyword_fetcher = test_factory_.GetFetcherByID(
+        SearchProvider::kKeywordProviderURLFetcherID);
+    ASSERT_TRUE(keyword_fetcher);
+    keyword_fetcher->set_response_code(200);
+    keyword_fetcher->SetResponseString(keyword_fetcher_response);
+    keyword_fetcher->delegate()->OnURLFetchComplete(keyword_fetcher);
+  }
+  RunTillProviderDone();
+}
+
 GURL SearchProviderTest::AddSearchToHistory(TemplateURL* t_url,
                                             base::string16 term,
                                             int visit_count) {
   HistoryService* history =
       HistoryServiceFactory::GetForProfile(&profile_,
                                            Profile::EXPLICIT_ACCESS);
   GURL search(t_url->url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(term),
       TemplateURLServiceFactory::GetForProfile(
           &profile_)->search_terms_data()));
@@ skipping 39 matching lines @@
   // Tell the SearchProvider the default suggest query is done.
   default_fetcher->set_response_code(200);
   default_fetcher->delegate()->OnURLFetchComplete(default_fetcher);
 }
 
 void SearchProviderTest::ForcedQueryTestHelper(
     const std::string& input,
     const std::string& json,
     const std::string expected_matches[3],
     const std::string& error_description) {
-  QueryForInput(ASCIIToUTF16(input), false, false);
-  net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
-      SearchProvider::kDefaultProviderURLFetcherID);
-  ASSERT_TRUE(fetcher);
-  fetcher->set_response_code(200);
-  fetcher->SetResponseString(json);
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
-  RunTillProviderDone();
+  // Send the query twice in order to have a synchronous pass after the first
+  // response is received.  This is necessary because SearchProvider doesn't
+  // allow an asynchronous response to change the default match.
+  for (size_t i = 0; i < 2; ++i) {
+    QueryForInputAndWaitForFetcherResponses(
+        ASCIIToUTF16(input), false, json, std::string());
+  }
 
   const ACMatches& matches = provider_->matches();
   ASSERT_LE(matches.size(), 3u);
   size_t i = 0;
   // Ensure that the returned matches equal the expectations.
   for (; i < matches.size(); ++i) {
     EXPECT_EQ(ASCIIToUTF16(expected_matches[i]), matches[i].contents) <<
         error_description;
   }
   // Ensure that no expected matches are missing.
   for (; i < 3u; ++i) {
     EXPECT_EQ(std::string(), expected_matches[i]) <<
         "Case #" << i << ": " << error_description;
   }
 }
 
+void SearchProviderTest::CheckMatches(const std::string& description,
+                                      const size_t num_expected_matches,
+                                      const ExpectedMatch expected_matches[],
+                                      const ACMatches& matches) {
+  ASSERT_FALSE(matches.empty());
+  ASSERT_LE(matches.size(), num_expected_matches);
+  size_t i = 0;
+  SCOPED_TRACE(description);
+  // Ensure that the returned matches equal the expectations.
+  for (; i < matches.size(); ++i) {
+    SCOPED_TRACE(" Case # " + base::IntToString(i));
+    EXPECT_EQ(ASCIIToUTF16(expected_matches[i].contents), matches[i].contents);
+    EXPECT_EQ(expected_matches[i].allowed_to_be_default_match,
+              matches[i].allowed_to_be_default_match);
+  }
+  // Ensure that no expected matches are missing.
+  for (; i < num_expected_matches; ++i) {
+    SCOPED_TRACE(" Case # " + base::IntToString(i));
+    EXPECT_EQ(kNotApplicable, expected_matches[i].contents);
+  }
+}
+
 void SearchProviderTest::ResetFieldTrialList() {
   // Destroy the existing FieldTrialList before creating a new one to avoid
   // a DCHECK.
   field_trial_list_.reset();
   field_trial_list_.reset(new base::FieldTrialList(
       new metrics::SHA1EntropyProvider("foo")));
   variations::testing::ClearAllVariationParams();
   base::FieldTrial* trial = base::FieldTrialList::CreateFieldTrial(
       "AutocompleteDynamicTrial_0", "DefaultGroup");
   trial->group();
@@ skipping 621 matching lines @@
                    ASCIIToUTF16("k a")) } },
   };
 
   RunTest(cases, arraysize(cases), false);
 }
 
 // Verifies Navsuggest results don't set a TemplateURL, which Instant relies on.
 // Also verifies that just the *first* navigational result is listed as a match
 // if suggested relevance scores were not sent.
 TEST_F(SearchProviderTest, NavSuggestNoSuggestedRelevanceScores) {
-  QueryForInput(ASCIIToUTF16("a.c"), false, false);
-
-  // Make sure the default providers suggest service was queried.
-  net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
-      SearchProvider::kDefaultProviderURLFetcherID);
-  ASSERT_TRUE(fetcher);
-
-  // Tell the SearchProvider the suggest query is done.
-  fetcher->set_response_code(200);
-  fetcher->SetResponseString(
+  QueryForInputAndWaitForFetcherResponses(
+      ASCIIToUTF16("a.c"), false,
       "[\"a.c\",[\"a.com\", \"a.com/b\"],[\"a\", \"b\"],[],"
-      "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"]}]");
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
-  fetcher = NULL;
-
-  // Run till the history results complete.
-  RunTillProviderDone();
+      "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"]}]",
+      std::string());
 
   // 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(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);
-  ASSERT_TRUE(fetcher);
-
-  // Tell the SearchProvider the suggest query is done.
-  fetcher->set_response_code(200);
-  fetcher->SetResponseString("[\"a\",[\"a1\", \"a2\", \"a3\", \"a4\"]]");
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
-  fetcher = NULL;
-
-  // Run till the history results complete.
-  RunTillProviderDone();
+  QueryForInputAndWaitForFetcherResponses(
+      ASCIIToUTF16("a"), false, "[\"a\",[\"a1\", \"a2\", \"a3\", \"a4\"]]",
+      std::string());
 
   // 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);
+  EXPECT_FALSE(match_a1.allowed_to_be_default_match);
+  EXPECT_FALSE(match_a2.allowed_to_be_default_match);
+  EXPECT_FALSE(match_a3.allowed_to_be_default_match);
 }
 
 // Verifies that the default provider abandons suggested relevance scores
 // when in keyword mode.  This should happen regardless of whether the
 // keyword provider returns suggested relevance scores.
 TEST_F(SearchProviderTest, DefaultProviderNoSuggestRelevanceInKeywordMode) {
   struct {
     const std::string default_provider_json;
     const std::string keyword_provider_json;
     const std::string matches[5];
@@ skipping 11 matching lines @@
     { "[\"k a\",[\"k adefault-query\", \"adefault.com\"],[],[],"
       "{\"google:verbatimrelevance\":9700,"
       "\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\"],"
       "\"google:suggestrelevance\":[9900, 9800]}]",
       "[\"a\",[\"akeyword-query\"],[],[],{\"google:suggesttype\":[\"QUERY\"],"
       "\"google:verbatimrelevance\":9500,"
       "\"google:suggestrelevance\":[9600]}]",
       { "akeyword-query", "a", "k a", "adefault.com", "k adefault-query" } }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
-    QueryForInput(ASCIIToUTF16("k a"), false, true);
-    net::TestURLFetcher* default_fetcher =
-        test_factory_.GetFetcherByID(
-            SearchProvider::kDefaultProviderURLFetcherID);
-    ASSERT_TRUE(default_fetcher);
-    default_fetcher->set_response_code(200);
-    default_fetcher->SetResponseString(cases[i].default_provider_json);
-    default_fetcher->delegate()->OnURLFetchComplete(default_fetcher);
-    net::TestURLFetcher* keyword_fetcher =
-        test_factory_.GetFetcherByID(
-            SearchProvider::kKeywordProviderURLFetcherID);
-    ASSERT_TRUE(keyword_fetcher);
-    keyword_fetcher->set_response_code(200);
-    keyword_fetcher->SetResponseString(cases[i].keyword_provider_json);
-    keyword_fetcher->delegate()->OnURLFetchComplete(keyword_fetcher);
-    RunTillProviderDone();
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    // Send the query twice in order to have a synchronous pass after the first
+    // response is received.  This is necessary because SearchProvider doesn't
+    // allow an asynchronous response to change the default match.
+    for (size_t j = 0; j < 2; ++j) {
+      QueryForInputAndWaitForFetcherResponses(
+          ASCIIToUTF16("k a"), true, cases[i].default_provider_json,
+          cases[i].keyword_provider_json);
+    }
 
-    const std::string description = "for input with default_provider_json=" +
+    SCOPED_TRACE(
+        "for input with default_provider_json=" +
         cases[i].default_provider_json + " and keyword_provider_json=" +
-        cases[i].keyword_provider_json;
+        cases[i].keyword_provider_json);
     const ACMatches& matches = provider_->matches();
     ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
-    for (; j < matches.size(); ++j) {
-      EXPECT_EQ(ASCIIToUTF16(cases[i].matches[j]), matches[j].contents) <<
-          description;
-    }
+    for (; j < matches.size(); ++j)
+      EXPECT_EQ(ASCIIToUTF16(cases[i].matches[j]), matches[j].contents);
     // Ensure that no expected matches are missing.
     for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j)
-      EXPECT_EQ(std::string(), cases[i].matches[j]) << description;
+      EXPECT_EQ(std::string(), cases[i].matches[j]);
   }
 }
 
 // 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 DefaultFetcherMatch matches[6];
+    const ExpectedMatch matches[6];
     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, kEmptyMatch,
-        kEmptyMatch },
+      { { "a", true }, { "c", false }, { "b", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch },
       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,
-        kEmptyMatch, kEmptyMatch },
+      { { "a", true }, { "c.com", false }, { "b.com", false },
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       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,
-        kEmptyMatch, kEmptyMatch },
+      { { "a", true }, { "b.com", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       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, kEmptyMatch,
-        kEmptyMatch },
+      { { "a", true}, { "a1", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":9998,"
                              "\"google:suggestrelevance\":[9999]}]",
-      { { "a1", true }, { "a", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a1", true }, { "a", true }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0,"
                              "\"google:suggestrelevance\":[9999]}]",
-      { { "a1", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a1", true }, kEmptyExpectedMatch, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       "1" },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":-1,"
                              "\"google:suggestrelevance\":[9999]}]",
-      { { "a1", true }, { "a", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a1", true }, { "a", true }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       "1" },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9999,"
         "\"google:suggestrelevance\":[9998]}]",
-      { { "a", true }, { "a.com", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a", true }, { "a.com", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9998,"
         "\"google:suggestrelevance\":[9999]}]",
-      { { "a.com", true }, { "a", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a.com", true }, { "a", true }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       ".com" },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9999]}]",
-      { { "a.com", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a.com", true }, kEmptyExpectedMatch, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       ".com" },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:verbatimrelevance\":-1,"
         "\"google:suggestrelevance\":[9999]}]",
-      { { "a.com", true }, { "a", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a.com", true }, { "a", true }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       ".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, kEmptyMatch,
-        kEmptyMatch },
+      { { "a1", true }, { "a", true }, { "a2", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch },
       "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.
+    // Check that an inlineable result appears first regardless of its score.
+    // Also, if the result set lacks a single inlineable result, abandon the
+    // request to suppress verbatim (verbatim_relevance=0), which will then
+    // cause verbatim to appear (first).
     { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999]}]",
-      { { "b", false }, { "a", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a", true }, { "b", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
     { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999],"
                             "\"google:verbatimrelevance\":0}]",
-      { { "a", true }, { "b", false }, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a", true }, { "b", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999]}]",
-      { { "b.com", false }, { "a", true }, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch, kEmptyMatch },
+      { { "a", true }, { "b.com", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999],"
         "\"google:verbatimrelevance\":0}]",
-      { { "a", true }, { "b.com", false }, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch, kEmptyMatch },
+      { { "a", true }, { "b.com", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
 
     // Allow low-scoring matches.
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0}]",
-      { { "a1", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a1", true }, kEmptyExpectedMatch, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       "1" },
-    { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":1}]",
-      { { "a1", true }, { "a", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+    { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":10}]",
+      { { "a1", true }, { "a", true }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       "1" },
-    { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[1],"
+    { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[10],"
                              "\"google:verbatimrelevance\":0}]",
-      { { "a1", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a1", true }, kEmptyExpectedMatch, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       "1" },
-    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 2],"
+    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[10, 20],"
                                      "\"google:verbatimrelevance\":0}]",
-      { { "a2", true }, { "a1", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a2", true }, { "a1", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       "2" },
-    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 3],"
-      "\"google:verbatimrelevance\":2}]",
-      { { "a2", true }, { "a", true }, { "a1", true }, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[10, 30],"
+      "\"google:verbatimrelevance\":20}]",
+      { { "a2", true }, { "a", true }, { "a1", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch },
       "2" },
     { "[\"a\",[\"http://a.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
-        "\"google:suggestrelevance\":[1],"
+        "\"google:suggestrelevance\":[10],"
         "\"google:verbatimrelevance\":0}]",
-      { { "a.com", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a.com", true }, kEmptyExpectedMatch, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       ".com" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
-        "\"google:suggestrelevance\":[1, 2],"
+        "\"google:suggestrelevance\":[10, 20],"
         "\"google:verbatimrelevance\":0}]",
-      { { "a2.com", true }, { "a1.com", true }, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch, kEmptyMatch },
+      { { "a2.com", true }, { "a1.com", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       "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]}]",
+       "{\"google:suggestrelevance\":[10, 20, 30, 40, 50, 60, 70]}]",
       { { "a", true }, { "h", false }, { "g", false }, { "f", false },
         { "e", false }, { "d", 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]}]",
+        "\"google:suggestrelevance\":[10, 20, 30, 40, 50, 60, 70]}]",
       { { "a", true }, { "h.com", false }, { "g.com", false },
         { "f.com", false }, { "e.com", false }, { "d.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, kEmptyMatch,
-        kEmptyMatch },
+    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[10]}]",
+      { { "a", true }, { "a1", false }, { "a2", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
-    { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[9999, 1]}]",
-      { { "a", true }, { "a1", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+    { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[9999, 10]}]",
+      { { "a", true }, { "a1", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
-        "\"google:suggestrelevance\":[1]}]",
-      { { "a", true }, { "a1.com", true }, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch, kEmptyMatch },
+        "\"google:suggestrelevance\":[10]}]",
+      { { "a", true }, { "a1.com", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
-       "\"google:suggestrelevance\":[9999, 1]}]",
-      { { "a", true }, { "a1.com", true }, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch, kEmptyMatch },
+       "\"google:suggestrelevance\":[9999, 10]}]",
+      { { "a", true }, { "a1.com", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       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, kEmptyMatch,
-        kEmptyMatch },
+      { { "a2", true }, { "a", true }, { "a1", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch },
       "2" },
     { "[\"a\",[\"a\", \"a1\", \"a2\"],[],[],"
        "{\"google:suggestrelevance\":[9998, 9997, 9999],"
         "\"google:verbatimrelevance\":0}]",
-      { { "a2", true }, { "a", true }, { "a1", true }, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a2", true }, { "a", true }, { "a1", false }, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch },
       "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, kEmptyMatch,
-        kEmptyMatch },
+      { { "a", true }, kEmptyExpectedMatch, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":0}]",
-      { { "a", true }, kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch,
-        kEmptyMatch },
+      { { "a", true }, kEmptyExpectedMatch, kEmptyExpectedMatch,
+        kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       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();
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    // Send the query twice in order to have a synchronous pass after the first
+    // response is received.  This is necessary because SearchProvider doesn't
+    // allow an asynchronous response to change the default match.
+    for (size_t j = 0; j < 2; ++j) {
+      QueryForInputAndWaitForFetcherResponses(
+          ASCIIToUTF16("a"), false, cases[i].json, std::string());
+    }
 
     const std::string description = "for input with json=" + cases[i].json;
-    const ACMatches& matches = provider_->matches();
-    ASSERT_FALSE(matches.empty());
-    // Find the first match that's allowed to be the default match and check
-    // its inline_autocompletion.
-    ACMatches::const_iterator it = FindDefaultMatch(matches);
-    ASSERT_NE(matches.end(), it);
-    EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
-              it->inline_autocompletion) << description;
-
-    ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
-    size_t j = 0;
-    // Ensure that the returned matches equal the expectations.
-    for (; j < matches.size(); ++j) {
-      EXPECT_EQ(ASCIIToUTF16(cases[i].matches[j].contents),
-                matches[j].contents) << description;
-      EXPECT_EQ(cases[i].matches[j].allowed_to_be_default_match,
-                matches[j].allowed_to_be_default_match) << description;
-    }
-    // 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;
+    CheckMatches(description, ARRAYSIZE_UNSAFE(cases[i].matches),
+                 cases[i].matches, provider_->matches());
   }
 }
 
 // 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
@@ skipping 45 matching lines @@
         { "b.com", false, false },
         { "k a",   false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Ensure that verbatimrelevance scores reorder or suppress verbatim.
     // Negative values will have no effect; the calculated value will be used.
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":9999,"
                              "\"google:suggestrelevance\":[9998]}]",
       { { "a",   true,  true },
-        { "a1",  true,  true },
+        { "a1",  true,  false },
         { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":9998,"
                              "\"google:suggestrelevance\":[9999]}]",
       { { "a1",  true,  true },
         { "a",   true,  true },
         { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
@@ skipping 18 matching lines @@
         { "a.com", false, false },
         { "k a",   false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Ensure that both types of relevance scores reorder matches together.
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[9999, 9997],"
                                      "\"google:verbatimrelevance\":9998}]",
       { { "a1",  true,  true },
         { "a",   true,  true },
-        { "a2",  true,  true },
+        { "a2",  true,  false },
         { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       "1" },
 
-    // Check that non-inlinable matches may be ranked as the highest result
-    // if there is at least one inlineable match.
+    // Check that an inlineable match appears first regardless of its score.
     { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999]}]",
-      { { "b",   true,  false },
-        { "a",   true,  true },
+      { { "a",   true,  true },
+        { "b",   true,  false },
         { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999]}]",
-      { { "b.com", false, false },
-        { "a",     true,  true },
+      { { "a",     true,  true },
+        { "b.com", false, false },
         { "k a",   false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
-    // On the other hand, if there is no inlineable match, restore
-    // the keyword verbatim score.
+    // If there is no inlineable match, restore the keyword verbatim score.
+    // The keyword verbatim match will then appear first.
     { "[\"a\",[\"b\"],[],[],{\"google:suggestrelevance\":[9999],"
                             "\"google:verbatimrelevance\":0}]",
-      { { "b",   true,  false },
-        { "a",   true,  true },
+      { { "a",   true,  true },
+        { "b",   true,  false },
         { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://b.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999],"
         "\"google:verbatimrelevance\":0}]",
-      { { "b.com", false, false },
-        { "a",     true,  true },
+      { { "a",     true,  true },
+        { "b.com", false, false },
         { "k a",   false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // The top result does not have to score as highly as calculated
     // verbatim.  i.e., there are no minimum score restrictions in
     // this provider.
     { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":0}]",
       { { "a1",  true,  true },
         { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
-    { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":1}]",
+    { "[\"a\",[\"a1\"],[],[],{\"google:verbatimrelevance\":10}]",
       { { "a1",  true,  true },
         { "k a", false, false },
         { "a",   true,  true },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
-    { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[1],"
+    { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[10],"
                              "\"google:verbatimrelevance\":0}]",
-      { { "k a", false, false },
-        { "a1",   true, true },
+      { { "a1",  true,  true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "1" },
-    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 2],"
+    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[10, 20],"
                                      "\"google:verbatimrelevance\":0}]",
-      {
+      { { "a2",  true,  true },
         { "k a", false, false },
-        { "a2",  true,  true },
-        { "a1",  true,  true },
+        { "a1",  true,  false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       "2" },
-    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1, 3],"
-      "\"google:verbatimrelevance\":2}]",
-      { { "k a", false, false },
-        { "a2",  true,  true },
+    { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[10, 30],"
+      "\"google:verbatimrelevance\":20}]",
+      { { "a2",  true,  true },
+        { "k a", false, false },
         { "a",   true,  true },
-        { "a1",  true,  true },
+        { "a1",  true,  false },
         kEmptyMatch, kEmptyMatch },
       "2" },
 
     // Ensure that all suggestions are considered, regardless of order.
     { "[\"a\",[\"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\"],[],[],"
-       "{\"google:suggestrelevance\":[1, 2, 3, 4, 5, 6, 7]}]",
+       "{\"google:suggestrelevance\":[10, 20, 30, 40, 50, 60, 70]}]",
       { { "a",   true,  true },
         { "k a", false, false },
         { "h",   true,  false },
         { "g",   true,  false },
         { "f",   true,  false },
         { "e",   true,  false } },
       std::string() },
     { "[\"a\",[\"http://b.com\", \"http://c.com\", \"http://d.com\","
               "\"http://e.com\", \"http://f.com\", \"http://g.com\","
               "\"http://h.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\","
                                 "\"NAVIGATION\", \"NAVIGATION\","
                                 "\"NAVIGATION\", \"NAVIGATION\","
                                 "\"NAVIGATION\"],"
-        "\"google:suggestrelevance\":[1, 2, 3, 4, 5, 6, 7]}]",
+        "\"google:suggestrelevance\":[10, 20, 30, 40, 50, 60, 70]}]",
       { { "a",     true,  true },
         { "k a",   false, false },
         { "h.com", false, false },
         { "g.com", false, false },
         { "f.com", false, false },
         { "e.com", false, false } },
       std::string() },
 
     // Ensure that incorrectly sized suggestion relevance lists are ignored.
     // Note that keyword suggestions by default (not in suggested relevance
     // mode) score more highly than the default verbatim.
     { "[\"a\",[\"a1\", \"a2\"],[],[],{\"google:suggestrelevance\":[1]}]",
       { { "a",   true,  true },
-        { "a1",  true,  true },
-        { "a2",  true,  true },
+        { "a1",  true,  false },
+        { "a2",  true,  false },
         { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"a1\"],[],[],{\"google:suggestrelevance\":[9999, 1]}]",
       { { "a",   true,  true },
-        { "a1",  true,  true },
+        { "a1",  true,  false },
         { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     // In this case, ignoring the suggested relevance scores means we keep
     // only one navsuggest result.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:suggestrelevance\":[1]}]",
       { { "a",      true,  true },
         { "a1.com", false, false },
         { "k a",    false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
        "\"google:suggestrelevance\":[9999, 1]}]",
       { { "a",      true,  true },
         { "a1.com", false, false },
         { "k a",    false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // Ensure that all 'verbatim' results are merged with their maximum score.
     { "[\"a\",[\"a\", \"a1\", \"a2\"],[],[],"
        "{\"google:suggestrelevance\":[9998, 9997, 9999]}]",
       { { "a2",  true,  true },
         { "a",   true,  true },
-        { "a1",  true,  true },
+        { "a1",  true,  false },
         { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       "2" },
     { "[\"a\",[\"a\", \"a1\", \"a2\"],[],[],"
        "{\"google:suggestrelevance\":[9998, 9997, 9999],"
         "\"google:verbatimrelevance\":0}]",
       { { "a2",  true,  true },
         { "a",   true,  true },
-        { "a1",  true,  true },
+        { "a1",  true,  false },
         { "k a", false, false },
         kEmptyMatch, kEmptyMatch },
       "2" },
 
     // Ensure that verbatim is always generated without other suggestions.
     // TODO(mpearson): Ensure the value of verbatimrelevance is respected
     // (except when suggested relevances are ignored).
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":1}]",
-      { { "k a", false, false },
-        { "a",   true,  true },
+      { { "a",   true,  true },
+        { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":0}]",
       { { "a",   true,  true },
         { "k a", false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
 
     // In reorder mode, navsuggestions will not need to be demoted (because
     // they are marked as not allowed to be default match and will be
     // reordered as necessary).
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9999]}]",
-      { { "a2.com", false, false },
+      { { "a",      true,  true },
+        { "a2.com", false, false },
         { "a1.com", false, false },
-        { "a",      true,  true },
         { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9999, 9998]}]",
-      { { "a1.com", false, false },
+      { { "a",      true,  true },
+        { "a1.com", false, false },
         { "a2.com", false, false },
-        { "a",      true,  true },
         { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"https://a/\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\"],"
         "\"google:suggestrelevance\":[9999]}]",
-      { { "https://a", false, false },
-        { "a",         true,  true },
+      { { "a",         true,  true },
+        { "https://a", false, false },
         { "k a",       false, false },
         kEmptyMatch, kEmptyMatch, kEmptyMatch },
       std::string() },
     // Check when navsuggest scores more than verbatim and there is query
     // suggestion but it scores lower.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9999, 1300]}]",
-      { { "a2.com", false, false },
+      { { "a",      true,  true },
+        { "a2.com", false, false },
         { "a1.com", false, false },
-        { "a",      true,  true },
-        { "a3",     true,  true },
+        { "a3",     true,  false },
         { "k a",    false, false },
         kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9999, 9998, 1300]}]",
-      { { "a1.com", false, false },
+      { { "a",      true,  true },
+        { "a1.com", false, false },
         { "a2.com", false, false },
-        { "a",      true,  true },
-        { "a3",     true,  true },
+        { "a3",     true,  false },
         { "k a",    false, false },
         kEmptyMatch },
       std::string() },
     // Check when navsuggest scores more than a query suggestion.  There is
     // a verbatim but it scores lower.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9999, 9997]}]",
-      { { "a2.com", false, false },
+      { { "a3",     true,  true },
+        { "a2.com", false, false },
         { "a1.com", false, false },
-        { "a3",     true,  true },
         { "a",      true,  true },
         { "k a",    false, false },
         kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9999, 9998, 9997]}]",
-      { { "a1.com", false, false },
+      { { "a3",     true,  true },
+        { "a1.com", false, false },
         { "a2.com", false, false },
-        { "a3",     true,  true },
         { "a",      true,  true },
         { "k a",    false, false },
         kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9998, 9999, 9997]}]",
-      { { "a2.com", false, false },
+      { { "a3",     true,  true },
+        { "a2.com", false, false },
         { "a1.com", false, false },
-        { "a3",     true,  true },
         { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9999, 9998, 9997]}]",
-      { { "a1.com", false, false },
+      { { "a3",     true,  true },
+        { "a1.com", false, false },
         { "a2.com", false, false },
-        { "a3",     true,  true },
         { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       "3" },
     // Check when there is neither verbatim nor a query suggestion that,
     // because we can't demote navsuggestions below a query suggestion,
     // we restore the keyword verbatim score.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9998, 9999]}]",
-      { { "a2.com", false, false },
+      { { "a",      true,  true },
+        { "a2.com", false, false },
         { "a1.com", false, false },
-        { "a",      true,  true },
         { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
         "\"google:verbatimrelevance\":0,"
         "\"google:suggestrelevance\":[9999, 9998]}]",
-      { { "a1.com", false, false },
+      { { "a",      true,  true },
+        { "a1.com", false, false },
         { "a2.com", false, false },
-        { "a",      true,  true },
         { "k a",    false, false },
         kEmptyMatch, kEmptyMatch },
       std::string() },
     // More checks that everything works when it's not necessary to demote.
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9997, 9998, 9999]}]",
       { { "a3",     true,  true },
         { "a2.com", false, false },
         { "a1.com", false, false },
         { "a",      true,  true },
         { "k a",    false, false },
         kEmptyMatch },
       "3" },
     { "[\"a\",[\"http://a1.com\", \"http://a2.com\", \"a3\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\", \"QUERY\"],"
         "\"google:verbatimrelevance\":9990,"
         "\"google:suggestrelevance\":[9998, 9997, 9999]}]",
       { { "a3",     true,  true },
         { "a1.com", false, false },
         { "a2.com", false, false },
         { "a",      true,  true },
         { "k a",    false, false },
         kEmptyMatch },
       "3" },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
-    QueryForInput(ASCIIToUTF16("k a"), false, true);
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    // Send the query twice in order to have a synchronous pass after the first
+    // response is received.  This is necessary because SearchProvider doesn't
+    // allow an asynchronous response to change the default match.
+    for (size_t j = 0; j < 2; ++j) {
+      QueryForInput(ASCIIToUTF16("k a"), false, true);
 
-    // Set up a default fetcher with no results.
-    net::TestURLFetcher* default_fetcher =
-        test_factory_.GetFetcherByID(
-            SearchProvider::kDefaultProviderURLFetcherID);
-    ASSERT_TRUE(default_fetcher);
-    default_fetcher->set_response_code(200);
-    default_fetcher->delegate()->OnURLFetchComplete(default_fetcher);
-    default_fetcher = NULL;
+      // Set up a default fetcher with no results.
+      net::TestURLFetcher* default_fetcher =
+          test_factory_.GetFetcherByID(
+              SearchProvider::kDefaultProviderURLFetcherID);
+      ASSERT_TRUE(default_fetcher);
+      default_fetcher->set_response_code(200);
+      default_fetcher->delegate()->OnURLFetchComplete(default_fetcher);
+      default_fetcher = NULL;
 
-    // Set up a keyword fetcher with provided results.
-    net::TestURLFetcher* keyword_fetcher =
-        test_factory_.GetFetcherByID(
-            SearchProvider::kKeywordProviderURLFetcherID);
-    ASSERT_TRUE(keyword_fetcher);
-    keyword_fetcher->set_response_code(200);
-    keyword_fetcher->SetResponseString(cases[i].json);
-    keyword_fetcher->delegate()->OnURLFetchComplete(keyword_fetcher);
-    keyword_fetcher = NULL;
-    RunTillProviderDone();
+      // Set up a keyword fetcher with provided results.
+      net::TestURLFetcher* keyword_fetcher =
+          test_factory_.GetFetcherByID(
+              SearchProvider::kKeywordProviderURLFetcherID);
+      ASSERT_TRUE(keyword_fetcher);
+      keyword_fetcher->set_response_code(200);
+      keyword_fetcher->SetResponseString(cases[i].json);
+      keyword_fetcher->delegate()->OnURLFetchComplete(keyword_fetcher);
+      keyword_fetcher = NULL;
+      RunTillProviderDone();
+    }
 
-    const std::string description = "for input with json=" + cases[i].json;
+    SCOPED_TRACE("for input with json=" + cases[i].json);
     const ACMatches& matches = provider_->matches();
     ASSERT_FALSE(matches.empty());
     // Find the first match that's allowed to be the default match and check
     // its inline_autocompletion.
     ACMatches::const_iterator it = FindDefaultMatch(matches);
     ASSERT_NE(matches.end(), it);
     EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
-              it->inline_autocompletion) << description;
+              it->inline_autocompletion);
 
     ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
       EXPECT_EQ(ASCIIToUTF16(cases[i].matches[j].contents),
-                matches[j].contents) << description;
+                matches[j].contents);
       EXPECT_EQ(cases[i].matches[j].from_keyword,
-                matches[j].keyword == ASCIIToUTF16("k")) << description;
+                matches[j].keyword == ASCIIToUTF16("k"));
       EXPECT_EQ(cases[i].matches[j].allowed_to_be_default_match,
-                matches[j].allowed_to_be_default_match) << description;
+                matches[j].allowed_to_be_default_match);
     }
     // 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;
+    for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j) {
+      SCOPED_TRACE(" Case # " + base::IntToString(i));
+      EXPECT_EQ(kNotApplicable, cases[i].matches[j].contents);
+    }
   }
 }
 
+TEST_F(SearchProviderTest, DontInlineAutocompleteAsynchronously) {
+  // This test sends two separate queries, each receiving different JSON
+  // replies, and checks that at each stage of processing (receiving first
+  // asynchronous response, handling new keystroke synchronously / sending the
+  // second request, and receiving the second asynchronous response) we have the
+  // expected matches.  In particular, receiving the second response shouldn't
+  // cause an unexpected inline autcompletion.
+  struct {
+    const std::string first_json;
+    const ExpectedMatch first_async_matches[4];
+    const ExpectedMatch sync_matches[4];
+    const std::string second_json;
+    const ExpectedMatch second_async_matches[4];
+  } cases[] = {
+    // A simple test that verifies we don't inline autocomplete after the
+    // first asynchronous response, but we do at the next keystroke if the
+    // response's results were good enough.  Furthermore, we should continue
+    // inline autocompleting after the second asynchronous response if the new
+    // top suggestion is the same as the old inline autocompleted suggestion.
+    { "[\"a\",[\"ab1\", \"ab2\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[9002, 9001]}]",
+      { { "a", true }, { "ab1", false }, { "ab2", false },
+        kEmptyExpectedMatch },
+      { { "ab1", true }, { "ab2", true }, { "ab", true },
+        kEmptyExpectedMatch },
+      "[\"ab\",[\"ab1\", \"ab2\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[9002, 9001]}]",
+      { { "ab1", true }, { "ab2", false }, { "ab", true },
+        kEmptyExpectedMatch } },
+    // Ditto, just for a navigation suggestion.
+    { "[\"a\",[\"ab1.com\", \"ab2.com\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[9002, 9001]}]",
+      { { "a", true }, { "ab1.com", false }, { "ab2.com", false },
+        kEmptyExpectedMatch },
+      { { "ab1.com", true }, { "ab2.com", true }, { "ab", true },
+        kEmptyExpectedMatch },
+      "[\"ab\",[\"ab1.com\", \"ab2.com\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[9002, 9001]}]",
+      { { "ab1.com", true }, { "ab2.com", false }, { "ab", true },
+        kEmptyExpectedMatch } },
+    // A more realistic test of the same situation.
+    { "[\"a\",[\"abcdef\", \"abcdef.com\", \"abc\"],[],[],"
+       "{\"google:verbatimrelevance\":900,"
+        "\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\", \"QUERY\"],"
+        "\"google:suggestrelevance\":[1250, 1200, 1000]}]",
+      { { "a", true }, { "abcdef", false }, { "abcdef.com", false },
+        { "abc", false } },
+      { { "abcdef", true }, { "abcdef.com", true }, { "abc", true },
+        { "ab", true } },
+      "[\"ab\",[\"abcdef\", \"abcdef.com\", \"abc\"],[],[],"
+       "{\"google:verbatimrelevance\":900,"
+        "\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\", \"QUERY\"],"
+        "\"google:suggestrelevance\":[1250, 1200, 1000]}]",
+      { { "abcdef", true }, { "abcdef.com", false }, { "abc", false },
+        { "ab", true } } },
+
+    // Without an original inline autcompletion, a new inline autcompletion
+    // should be rejected.
+    { "[\"a\",[\"ab1\", \"ab2\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[8000, 7000]}]",
+      { { "a", true }, { "ab1", false }, { "ab2", false },
+        kEmptyExpectedMatch },
+      { { "ab", true }, { "ab1", true }, { "ab2", true },
+        kEmptyExpectedMatch },
+      "[\"ab\",[\"ab1\", \"ab2\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[9002, 9001]}]",
+      { { "ab", true }, { "ab1", false }, { "ab2", false },
+        kEmptyExpectedMatch } },
+    // For the same test except with the queries scored in the opposite order
+    // on the second JSON response, the queries should be ordered by the second
+    // response's scores, not the first.
+    { "[\"a\",[\"ab1\", \"ab2\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[8000, 7000]}]",
+      { { "a", true }, { "ab1", false }, { "ab2", false },
+        kEmptyExpectedMatch },
+      { { "ab", true }, { "ab1", true }, { "ab2", true },
+        kEmptyExpectedMatch },
+      "[\"ab\",[\"ab1\", \"ab2\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[9001, 9002]}]",
+      { { "ab", true }, { "ab2", false }, { "ab1", false },
+        kEmptyExpectedMatch } },
+    // Now, the same verifications but with the new inline autocompletion as a
+    // navsuggestion.  The new autocompletion should still be rejected.
+    { "[\"a\",[\"ab1.com\", \"ab2.com\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[8000, 7000]}]",
+      { { "a", true }, { "ab1.com", false }, { "ab2.com", false },
+        kEmptyExpectedMatch },
+      { { "ab", true }, { "ab1.com", true }, { "ab2.com", true },
+        kEmptyExpectedMatch },
+      "[\"ab\",[\"ab1.com\", \"ab2.com\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[9002, 9001]}]",
+      { { "ab", true }, { "ab1.com", false }, { "ab2.com", false },
+        kEmptyExpectedMatch } },
+    { "[\"a\",[\"ab1.com\", \"ab2.com\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[8000, 7000]}]",
+      { { "a", true }, { "ab1.com", false }, { "ab2.com", false },
+        kEmptyExpectedMatch },
+      { { "ab", true }, { "ab1.com", true }, { "ab2.com", true },
+        kEmptyExpectedMatch },
+      "[\"ab\",[\"ab1.com\", \"ab2.com\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"],"
+        "\"google:suggestrelevance\":[9001, 9002]}]",
+      { { "ab", true }, { "ab2.com", false }, { "ab1.com", false },
+        kEmptyExpectedMatch } },
+
+    // It's okay to abandon an inline autocompletion asynchronously.
+    { "[\"a\",[\"ab1\", \"ab2\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[9002, 9001]}]",
+      { { "a", true }, { "ab1", false }, { "ab2", false },
+        kEmptyExpectedMatch },
+      { { "ab1", true }, { "ab2", true }, { "ab", true },
+        kEmptyExpectedMatch },
+      "[\"ab\",[\"ab1\", \"ab2\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[8000, 7000]}]",
+      { { "ab", true }, { "ab1", true }, { "ab2", false },
+        kEmptyExpectedMatch } },
+
+    // Note: it's possible that the suggest server returns a suggestion with
+    // an inline autocompletion (that as usual we delay in allowing it to
+    // be displayed as an inline autocompletion until the next keystroke),
+    // then, in response to the next keystroke, the server returns a different
+    // suggestion as an inline autocompletion.  This is not likely to happen.
+    // Regardless, if it does, one could imagine three different behaviors:
+    // - keep the original inline autocompletion until the next keystroke
+    //   (i.e., don't abandon an inline autocompletion asynchronously), then
+    //   use the new suggestion
+    // - abandon all inline autocompletions upon the server response, then use
+    //   the new suggestion on the next keystroke
+    // - ignore the new inline autocompletion provided by the server, yet
+    //   possibly keep the original if it scores well in the most recent
+    //   response, then use the new suggestion on the next keystroke
+    // All of these behaviors are reasonable.  The main thing we want to
+    // ensure is that the second asynchronous response shouldn't cause *a new*
+    // inline autocompletion to be displayed.  We test that here.
+    // The current implementation does the third bullet, but all of these
+    // behaviors seem reasonable.
+    { "[\"a\",[\"ab1\", \"ab2\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[9002, 9001]}]",
+      { { "a", true }, { "ab1", false }, { "ab2", false },
+        kEmptyExpectedMatch },
+      { { "ab1", true }, { "ab2", true }, { "ab", true },
+        kEmptyExpectedMatch },
+      "[\"ab\",[\"ab1\", \"ab3\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[9002, 9900]}]",
+      { { "ab1", true }, { "ab3", false }, { "ab", true },
+        kEmptyExpectedMatch } },
+    { "[\"a\",[\"ab1\", \"ab2\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[9002, 9001]}]",
+      { { "a", true }, { "ab1", false }, { "ab2", false },
+        kEmptyExpectedMatch },
+      { { "ab1", true }, { "ab2", true }, { "ab", true },
+        kEmptyExpectedMatch },
+      "[\"ab\",[\"ab1\", \"ab3\"],[],[],"
+       "{\"google:verbatimrelevance\":9000,"
+        "\"google:suggestrelevance\":[8000, 9500]}]",
+      { { "ab", true }, { "ab3", false }, { "ab1", true },
+        kEmptyExpectedMatch } },
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    // First, send the query "a" and receive the JSON response |first_json|.
+    ClearAllResults();
+    QueryForInputAndWaitForFetcherResponses(
+        ASCIIToUTF16("a"), false, cases[i].first_json, std::string());
+
+    // Verify that the matches after the asynchronous results are as expected.
+    std::string description = "first asynchronous response for input with "
+        "first_json=" + cases[i].first_json;
+    CheckMatches(description, ARRAYSIZE_UNSAFE(cases[i].first_async_matches),
+                 cases[i].first_async_matches, provider_->matches());
+
+    // Then, send the query "ab" and check the synchronous matches.
+    description = "synchronous response after the first keystroke after input "
+        "with first_json=" + cases[i].first_json;
+    QueryForInput(ASCIIToUTF16("ab"), false, false);
+    CheckMatches(description, ARRAYSIZE_UNSAFE(cases[i].sync_matches),
+                 cases[i].sync_matches, provider_->matches());
+
+    // Finally, get the provided JSON response, |second_json|, and verify the
+    // matches after the second asynchronous response are as expected.
+    description = "second asynchronous response after input with first_json=" +
+        cases[i].first_json + " and second_json=" + cases[i].second_json;
+    net::TestURLFetcher* second_fetcher =
+        test_factory_.GetFetcherByID(
+            SearchProvider::kDefaultProviderURLFetcherID);
+    ASSERT_TRUE(second_fetcher);
+    second_fetcher->set_response_code(200);
+    second_fetcher->SetResponseString(cases[i].second_json);
+    second_fetcher->delegate()->OnURLFetchComplete(second_fetcher);
+    RunTillProviderDone();
+    CheckMatches(description, ARRAYSIZE_UNSAFE(cases[i].second_async_matches),
+                 cases[i].second_async_matches, provider_->matches());
+  }
+}
+
 TEST_F(SearchProviderTest, LocalAndRemoteRelevances) {
   // We hardcode the string "term1" below, so ensure that the search term that
   // got added to history already is that string.
   ASSERT_EQ(ASCIIToUTF16("term1"), term1_);
   base::string16 term = term1_.substr(0, term1_.length() - 1);
 
   AddSearchToHistory(default_t_url_, term + ASCIIToUTF16("2"), 2);
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   struct {
@@ skipping 40 matching lines @@
         "\"google:suggestrelevance\":[1440, 1430, 1420, 1410, 1400, 1390]}]",
       { "term", "a1", "a2", "a3", "a4", "a5" } },
     { term,
       "[\"term\",[\"a1\", \"a2\", \"a3\", \"a4\"],[],[],"
        "{\"google:suggesttype\":[\"QUERY\", \"QUERY\", \"QUERY\", \"QUERY\"],"
         "\"google:verbatimrelevance\":1450,"
         "\"google:suggestrelevance\":[1430, 1410, 1390, 1370]}]",
       { "term", "a1", "a2", "term2", "a3", "a4" } }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
-    QueryForInput(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();
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    QueryForInputAndWaitForFetcherResponses(
+        cases[i].input, false, cases[i].json, std::string());
 
     const std::string description = "for input with json=" + cases[i].json;
     const ACMatches& matches = provider_->matches();
 
     // Ensure no extra matches are present.
     ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
 
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j)
@@ skipping 13 matching lines @@
     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 DefaultFetcherUrlInputMatch output[4];
   } cases[] = {
-    // Ensure NAVIGATION matches are allowed to be listed first for URL
-    // input regardless of whether the match is inlineable.  Note that
-    // non-inlineable matches should not be allowed to be the default match.
+    // Ensure NAVIGATION matches are allowed to be listed first for URL input.
+    // Non-inlineable matches should not be allowed to be the default match.
+    // Note that the top-scoring inlineable match is moved to the top
+    // regardless of its score.
     { "a.com", "[\"a.com\",[\"http://b.com/\"],[],[],"
                 "{\"google:suggesttype\":[\"NAVIGATION\"],"
                  "\"google:suggestrelevance\":[9999]}]",
-      { { "b.com",   AutocompleteMatchType::NAVSUGGEST,            false },
-        { "a.com",   AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+      { { "a.com",   AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+        { "b.com",   AutocompleteMatchType::NAVSUGGEST,            false },
         kEmptyMatch, kEmptyMatch } },
     { "a.com", "[\"a.com\",[\"https://b.com\"],[],[],"
                 "{\"google:suggesttype\":[\"NAVIGATION\"],"
                  "\"google:suggestrelevance\":[9999]}]",
-      { { "https://b.com", AutocompleteMatchType::NAVSUGGEST,           false },
-        { "a.com",         AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+      { { "a.com",         AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+        { "https://b.com", AutocompleteMatchType::NAVSUGGEST,           false },
         kEmptyMatch, kEmptyMatch } },
     { "a.com", "[\"a.com\",[\"http://a.com/a\"],[],[],"
                 "{\"google:suggesttype\":[\"NAVIGATION\"],"
                  "\"google:suggestrelevance\":[9999]}]",
       { { "a.com/a", AutocompleteMatchType::NAVSUGGEST,            true },
         { "a.com",   AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
         kEmptyMatch, kEmptyMatch } },
     { "a.com", "[\"a.com\",[\"https://a.com\"],[],[],"
                 "{\"google:suggesttype\":[\"NAVIGATION\"],"
                  "\"google:suggestrelevance\":[9999]}]",
       { { "https://a.com", AutocompleteMatchType::NAVSUGGEST,            true },
         { "a.com",         AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
         kEmptyMatch, kEmptyMatch } },
 
     // Ensure topmost inlineable 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",      AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
-        { "a.com info", AutocompleteMatchType::SEARCH_SUGGEST,        true },
+      { { "a.com",      AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true  },
+        { "a.com info", AutocompleteMatchType::SEARCH_SUGGEST,        false },
         kEmptyMatch, kEmptyMatch } },
     { "a.com", "[\"a.com\",[\"a.com info\"],[],[],"
                 "{\"google:suggestrelevance\":[9999]}]",
-      { { "a.com",   AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,   true },
-        { "a.com info", AutocompleteMatchType::SEARCH_SUGGEST,        true },
+      { { "a.com",      AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true  },
+        { "a.com info", AutocompleteMatchType::SEARCH_SUGGEST,        false },
         kEmptyMatch, kEmptyMatch } },
 
-    // Ensure the fallback mechanism allows inlinable NAVIGATION matches.
+    // Ensure the fallback mechanism allows inlineable NAVIGATION matches.
     { "a.com", "[\"a.com\",[\"a.com info\", \"http://a.com/b\"],[],[],"
                 "{\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\"],"
                  "\"google:suggestrelevance\":[9999, 9998]}]",
-      { { "a.com/b",    AutocompleteMatchType::NAVSUGGEST,            true },
-        { "a.com",      AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
-        { "a.com info", AutocompleteMatchType::SEARCH_SUGGEST,        true },
+      { { "a.com/b",    AutocompleteMatchType::NAVSUGGEST,            true  },
+        { "a.com info", AutocompleteMatchType::SEARCH_SUGGEST,        false },
+        { "a.com",      AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true  },
         kEmptyMatch } },
     { "a.com", "[\"a.com\",[\"a.com info\", \"http://a.com/b\"],[],[],"
                 "{\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\"],"
                  "\"google:suggestrelevance\":[9998, 9997],"
                  "\"google:verbatimrelevance\":9999}]",
       { { "a.com/b",    AutocompleteMatchType::NAVSUGGEST,            true },
         { "a.com",      AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
-        { "a.com info", AutocompleteMatchType::SEARCH_SUGGEST,        true },
+        { "a.com info", AutocompleteMatchType::SEARCH_SUGGEST,        false },
         kEmptyMatch } },
 
-    // Ensure topmost non-inlineable SUGGEST matches are allowed for URL
-    // input assuming the top inlineable match is not a query (i.e., is a
-    // NAVSUGGEST).
+    // Ensure non-inlineable SUGGEST matches are allowed for URL input
+    // assuming the best inlineable match is not a query (i.e., is a
+    // NAVSUGGEST).  The best inlineable match will be at the top of the
+    // list regardless of its score.
     { "a.com", "[\"a.com\",[\"info\"],[],[],"
                 "{\"google:suggestrelevance\":[9999]}]",
-      { { "info",  AutocompleteMatchType::SEARCH_SUGGEST,        false },
-        { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+      { { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true  },
+        { "info",  AutocompleteMatchType::SEARCH_SUGGEST,        false },
         kEmptyMatch, kEmptyMatch } },
     { "a.com", "[\"a.com\",[\"info\"],[],[],"
                 "{\"google:suggestrelevance\":[9999]}]",
-      { { "info",  AutocompleteMatchType::SEARCH_SUGGEST,        false },
-        { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true },
+      { { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true  },
+        { "info",  AutocompleteMatchType::SEARCH_SUGGEST,        false },
         kEmptyMatch, 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();
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    // Send the query twice in order to have a synchronous pass after the first
+    // response is received.  This is necessary because SearchProvider doesn't
+    // allow an asynchronous response to change the default match.
+    for (size_t j = 0; j < 2; ++j) {
+      QueryForInputAndWaitForFetcherResponses(
+          ASCIIToUTF16(cases[i].input), false, cases[i].json, std::string());
+    }
 
+    SCOPED_TRACE("input=" + cases[i].input + " json=" + cases[i].json);
     size_t j = 0;
     const ACMatches& matches = provider_->matches();
     ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].output));
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
       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].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(
-      SearchProvider::kDefaultProviderURLFetcherID);
-  ASSERT_TRUE(fetcher);
-
-  // Tell the SearchProvider the suggest query is done.
-  fetcher->set_response_code(200);
-  fetcher->SetResponseString(
+  QueryForInputAndWaitForFetcherResponses(
+      ASCIIToUTF16("foo"), false,
       "[\"foo\",[\"foo bar\"],[\"\"],[],"
       "{\"google:suggesttype\":[\"QUERY\"],"
-      "\"google:fieldtrialtriggered\":true}]");
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
-  fetcher = NULL;
-
-  // Run till the history results complete.
-  RunTillProviderDone();
+      "\"google:fieldtrialtriggered\":true}]",
+      std::string());
 
   {
     // Check for the match and field trial triggered bits.
     AutocompleteMatch match;
     EXPECT_TRUE(FindMatchWithContents(ASCIIToUTF16("foo bar"), &match));
     ProvidersInfo providers_info;
     provider_->AddProviderInfo(&providers_info);
     ASSERT_EQ(1U, providers_info.size());
     EXPECT_EQ(1, providers_info[0].field_trial_triggered_size());
     EXPECT_EQ(1, providers_info[0].field_trial_triggered_in_session_size());
@@ skipping 69 matching lines @@
     { "abc.com ",      "http://www.abc.com",
                               "www.abc.com",      std::string(), true,  true },
     { "abc.com/ ",     "http://www.abc.com",
                               "www.abc.com",      std::string(), true,  true },
     { "abc.com ",      "http://www.abc.com/bar",
                               "www.abc.com/bar",  "/bar",        false, false },
 
     // A suggestion that's equivalent to what the input gets fixed up to
     // should be inlined.
     { "abc.com:",      "http://abc.com/",
-                              "abc.com",      "", true, true },
+                              "abc.com",          std::string(), true,  true },
     { "abc.com:",      "http://www.abc.com",
-                              "www.abc.com",  "", true, true },
+                              "www.abc.com",      std::string(), true,  true },
 
     // 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", true, false },
     { "http",          "http://www.abc.com",
                        "http://www.abc.com", "://www.abc.com",    true, false },
 
     // 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", true, false },
@@ skipping 64 matching lines @@
                                    "c.com/path/file.htm?q=x#foo", true, false },
     { "ab",          "https://www.abc.com/path/file.htm?q=x#foo",
                      "https://www.abc.com/path/file.htm?q=x#foo",
                                    "c.com/path/file.htm?q=x#foo", true, false },
     { "ab",          "https://abc.com/path/file.htm?q=x#foo",
                      "https://abc.com/path/file.htm?q=x#foo",
                                "c.com/path/file.htm?q=x#foo",     true, false },
 
     // Forced query input should inline and retain the "?" prefix.
     { "?http://www.ab",  "http://www.abc.com",
-                        "?http://www.abc.com", "c.com", true, false },
+                        "?http://www.abc.com", "c.com",       true, false },
     { "?www.ab",         "http://www.abc.com",
-                               "?www.abc.com", "c.com", true, false },
+                               "?www.abc.com", "c.com",       true, false },
     { "?ab",             "http://www.abc.com",
-                               "?www.abc.com", "c.com", true, false },
+                               "?www.abc.com", "c.com",       true, false },
     { "?abc.com",        "http://www.abc.com",
-                               "?www.abc.com", "",      true, true },
+                               "?www.abc.com", std::string(), true, true },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     // First test regular mode.
     QueryForInput(ASCIIToUTF16(cases[i].input), false, false);
-    AutocompleteMatch match(
-        provider_->NavigationToMatch(SearchSuggestionParser::NavigationResult(
-            ChromeAutocompleteSchemeClassifier(&profile_), GURL(cases[i].url),
-            AutocompleteMatchType::NAVSUGGEST, base::string16(), std::string(),
-            false, 0, false, ASCIIToUTF16(cases[i].input), std::string())));
+    SearchSuggestionParser::NavigationResult result(
+        ChromeAutocompleteSchemeClassifier(&profile_), GURL(cases[i].url),
+        AutocompleteMatchType::NAVSUGGEST, base::string16(), std::string(),
+        false, 0, false, ASCIIToUTF16(cases[i].input), std::string());
+    result.set_received_after_last_keystroke(false);
+    AutocompleteMatch match(provider_->NavigationToMatch(result));
     EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
               match.inline_autocompletion);
     EXPECT_EQ(ASCIIToUTF16(cases[i].fill_into_edit), match.fill_into_edit);
     EXPECT_EQ(cases[i].allowed_to_be_default_match_in_regular_mode,
               match.allowed_to_be_default_match);
 
     // Then test prevent-inline-autocomplete mode.
     QueryForInput(ASCIIToUTF16(cases[i].input), true, false);
+    SearchSuggestionParser::NavigationResult result_prevent_inline(
+        ChromeAutocompleteSchemeClassifier(&profile_), GURL(cases[i].url),
+        AutocompleteMatchType::NAVSUGGEST, base::string16(), std::string(),
+        false, 0, false, ASCIIToUTF16(cases[i].input), std::string());
+    result_prevent_inline.set_received_after_last_keystroke(false);
     AutocompleteMatch match_prevent_inline(
-        provider_->NavigationToMatch(SearchSuggestionParser::NavigationResult(
-            ChromeAutocompleteSchemeClassifier(&profile_), GURL(cases[i].url),
-            AutocompleteMatchType::NAVSUGGEST, base::string16(), std::string(),
-            false, 0, false, ASCIIToUTF16(cases[i].input), std::string())));
+        provider_->NavigationToMatch(result_prevent_inline));
     EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
               match_prevent_inline.inline_autocompletion);
     EXPECT_EQ(ASCIIToUTF16(cases[i].fill_into_edit),
               match_prevent_inline.fill_into_edit);
     EXPECT_EQ(cases[i].allowed_to_be_default_match_in_prevent_inline_mode,
               match_prevent_inline.allowed_to_be_default_match);
   }
 }
 
 // Verifies that "http://" is not trimmed for input that is a leading substring.
 TEST_F(SearchProviderTest, NavigationInlineSchemeSubstring) {
   const base::string16 input(ASCIIToUTF16("ht"));
   const base::string16 url(ASCIIToUTF16("http://a.com"));
-  const SearchSuggestionParser::NavigationResult result(
+  SearchSuggestionParser::NavigationResult result(
       ChromeAutocompleteSchemeClassifier(&profile_), GURL(url),
       AutocompleteMatchType::NAVSUGGEST,
       base::string16(), std::string(), false, 0, false, input, std::string());
+  result.set_received_after_last_keystroke(false);
 
   // Check the offset and strings when inline autocompletion is allowed.
   QueryForInput(input, false, false);
   AutocompleteMatch match_inline(provider_->NavigationToMatch(result));
   EXPECT_EQ(url, match_inline.fill_into_edit);
   EXPECT_EQ(url.substr(2), match_inline.inline_autocompletion);
   EXPECT_TRUE(match_inline.allowed_to_be_default_match);
   EXPECT_EQ(url, match_inline.contents);
 
   // Check the same strings when inline autocompletion is prevented.
   QueryForInput(input, true, false);
   AutocompleteMatch match_prevent(provider_->NavigationToMatch(result));
   EXPECT_EQ(url, match_prevent.fill_into_edit);
   EXPECT_FALSE(match_prevent.allowed_to_be_default_match);
   EXPECT_EQ(url, match_prevent.contents);
 }
 
 // Verifies that input "w" marks a more significant domain label than "www.".
 TEST_F(SearchProviderTest, NavigationInlineDomainClassify) {
   QueryForInput(ASCIIToUTF16("w"), false, false);
-  AutocompleteMatch match(
-      provider_->NavigationToMatch(SearchSuggestionParser::NavigationResult(
-          ChromeAutocompleteSchemeClassifier(&profile_),
-          GURL("http://www.wow.com"),
-          AutocompleteMatchType::NAVSUGGEST, base::string16(), std::string(),
-          false, 0, false, ASCIIToUTF16("w"), std::string())));
+  SearchSuggestionParser::NavigationResult result(
+      ChromeAutocompleteSchemeClassifier(&profile_),
+      GURL("http://www.wow.com"), AutocompleteMatchType::NAVSUGGEST,
+      base::string16(), std::string(), false, 0, false, ASCIIToUTF16("w"),
+      std::string());
+  result.set_received_after_last_keystroke(false);
+  AutocompleteMatch match(provider_->NavigationToMatch(result));
   EXPECT_EQ(ASCIIToUTF16("ow.com"), match.inline_autocompletion);
   EXPECT_TRUE(match.allowed_to_be_default_match);
   EXPECT_EQ(ASCIIToUTF16("www.wow.com"), match.fill_into_edit);
   EXPECT_EQ(ASCIIToUTF16("www.wow.com"), match.contents);
 
   // Ensure that the match for input "w" is marked on "wow" and not "www".
   ASSERT_EQ(3U, match.contents_class.size());
   EXPECT_EQ(0U, match.contents_class[0].offset);
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL,
             match.contents_class[0].style);
@@ skipping 47 matching lines @@
       "\"google:suggesttype\":[\"QUERY\",\"ENTITY\"]}]",
       { { "x", "", "", "x", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED },
         { "xy", "", "", "xy", AutocompleteMatchType::SEARCH_SUGGEST },
         { "xy", "A", "p=v", "xy",
           AutocompleteMatchType::SEARCH_SUGGEST_ENTITY },
         kEmptyMatch,
         kEmptyMatch
       },
     },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
-    QueryForInput(ASCIIToUTF16(cases[i].input_text), false, false);
-
-    // Set up a default fetcher with provided results.
-    net::TestURLFetcher* fetcher =
-        test_factory_.GetFetcherByID(
-            SearchProvider::kDefaultProviderURLFetcherID);
-    ASSERT_TRUE(fetcher);
-    fetcher->set_response_code(200);
-    fetcher->SetResponseString(cases[i].response_json);
-    fetcher->delegate()->OnURLFetchComplete(fetcher);
-
-    RunTillProviderDone();
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    QueryForInputAndWaitForFetcherResponses(
+        ASCIIToUTF16(cases[i].input_text), false, cases[i].response_json,
+        std::string());
 
     const ACMatches& matches = provider_->matches();
     ASSERT_FALSE(matches.empty());
 
     SCOPED_TRACE("for input with json = " + cases[i].response_json);
 
     ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
@@ skipping 102 matching lines @@
       "[\"a\",[\"b\", \"c\"],[],[],{\"google:suggestrelevance\":[1, 2]}]",
       { { "a", false, AutocompleteMatchType::SEARCH_OTHER_ENGINE, true},
         { "k a", false, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, false },
         { "ab", false, AutocompleteMatchType::SEARCH_SUGGEST, false },
         { "c", false, AutocompleteMatchType::SEARCH_SUGGEST, true },
         { "b", false, AutocompleteMatchType::SEARCH_SUGGEST, true }
       },
     }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
-    QueryForInput(ASCIIToUTF16(cases[i].input_text), false,
-                  cases[i].prefer_keyword_provider_results);
-
-    // Set up a default fetcher with provided results.
-    net::TestURLFetcher* fetcher =
-        test_factory_.GetFetcherByID(
-            SearchProvider::kDefaultProviderURLFetcherID);
-    ASSERT_TRUE(fetcher);
-    fetcher->set_response_code(200);
-    fetcher->SetResponseString(cases[i].default_provider_response_json);
-    fetcher->delegate()->OnURLFetchComplete(fetcher);
-
-    if (cases[i].prefer_keyword_provider_results) {
-      // Set up a keyword fetcher with provided results.
-      net::TestURLFetcher* keyword_fetcher =
-          test_factory_.GetFetcherByID(
-              SearchProvider::kKeywordProviderURLFetcherID);
-      ASSERT_TRUE(keyword_fetcher);
-      keyword_fetcher->set_response_code(200);
-      keyword_fetcher->SetResponseString(
-          cases[i].keyword_provider_response_json);
-      keyword_fetcher->delegate()->OnURLFetchComplete(keyword_fetcher);
-      keyword_fetcher = NULL;
-    }
-
-    RunTillProviderDone();
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    QueryForInputAndWaitForFetcherResponses(
+        ASCIIToUTF16(cases[i].input_text),
+        cases[i].prefer_keyword_provider_results,
+        cases[i].default_provider_response_json,
+        cases[i].prefer_keyword_provider_results ?
+            cases[i].keyword_provider_response_json : std::string());
 
     const std::string description =
         "for input with json =" + cases[i].default_provider_response_json;
     const ACMatches& matches = provider_->matches();
     // The top match must inline and score as highly as calculated verbatim.
     ASSERT_FALSE(matches.empty());
     EXPECT_GE(matches[0].relevance, 1300);
 
     ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
     // Ensure that the returned matches equal the expectations.
     for (size_t j = 0; j < matches.size(); ++j) {
       SCOPED_TRACE(description);
       EXPECT_EQ(cases[i].matches[j].contents,
                 base::UTF16ToUTF8(matches[j].contents));
       EXPECT_EQ(cases[i].matches[j].allowed_to_be_prefetched,
                 SearchProvider::ShouldPrefetch(matches[j]));
       EXPECT_EQ(cases[i].matches[j].type, matches[j].type);
       EXPECT_EQ(cases[i].matches[j].from_keyword,
                 matches[j].keyword == ASCIIToUTF16("k"));
     }
   }
 }
 
 TEST_F(SearchProviderTest, XSSIGuardedJSONParsing_InvalidResponse) {
   ClearAllResults();
 
   std::string input_str("abc");
-  QueryForInput(ASCIIToUTF16(input_str), false, false);
-
-  // Set up a default fetcher with provided results.
-  net::TestURLFetcher* fetcher =
-      test_factory_.GetFetcherByID(
-          SearchProvider::kDefaultProviderURLFetcherID);
-  ASSERT_TRUE(fetcher);
-  fetcher->set_response_code(200);
-  fetcher->SetResponseString("this is a bad non-json response");
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
-
-  RunTillProviderDone();
+  QueryForInputAndWaitForFetcherResponses(
+      ASCIIToUTF16(input_str), false, "this is a bad non-json response",
+      std::string());
 
   const ACMatches& matches = provider_->matches();
 
   // Should have exactly one "search what you typed" match
   ASSERT_TRUE(matches.size() == 1);
   EXPECT_EQ(input_str, base::UTF16ToUTF8(matches[0].contents));
   EXPECT_EQ(AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
             matches[0].type);
 }
 
@@ skipping 41 matching lines @@
       "{\"google:suggesttype\":[\"QUERY\",\"QUERY\"],"
       "\"google:suggestrelevance\":[1, 2]}]",
       { { "a", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED },
         { "c", AutocompleteMatchType::SEARCH_SUGGEST },
         { "b", AutocompleteMatchType::SEARCH_SUGGEST },
         kEmptyMatch,
       },
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     ClearAllResults();
-    QueryForInput(ASCIIToUTF16(cases[i].input_text), false, false);
-
-    // Set up a default fetcher with provided results.
-    net::TestURLFetcher* fetcher =
-        test_factory_.GetFetcherByID(
-            SearchProvider::kDefaultProviderURLFetcherID);
-    ASSERT_TRUE(fetcher);
-    fetcher->set_response_code(200);
-    fetcher->SetResponseString(cases[i].default_provider_response_json);
-    fetcher->delegate()->OnURLFetchComplete(fetcher);
-
-    RunTillProviderDone();
+    QueryForInputAndWaitForFetcherResponses(
+        ASCIIToUTF16(cases[i].input_text), false,
+        cases[i].default_provider_response_json, std::string());
 
     const ACMatches& matches = provider_->matches();
     // The top match must inline and score as highly as calculated verbatim.
     ASSERT_FALSE(matches.empty());
     EXPECT_GE(matches[0].relevance, 1300);
 
     SCOPED_TRACE("for case: " + base::IntToString(i));
     ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
@@ skipping 14 matching lines @@
 // Test that deletion url gets set on an AutocompleteMatch when available for a
 // personalized query or a personalized URL.
 TEST_F(SearchProviderTest, ParseDeletionUrl) {
    struct Match {
      std::string contents;
      std::string deletion_url;
      AutocompleteMatchType::Type type;
    };
 
    const Match kEmptyMatch = {
-       kNotApplicable, "", AutocompleteMatchType::NUM_TYPES
+     kNotApplicable, std::string(), AutocompleteMatchType::NUM_TYPES
    };
 
    const char* url[] = {
     "http://defaultturl/complete/deleteitems"
        "?delq=ab&client=chrome&deltok=xsrf124",
     "http://defaultturl/complete/deleteitems"
        "?delq=www.amazon.com&client=chrome&deltok=xsrf123",
-     };
+   };
 
    struct {
        const std::string input_text;
        const std::string response_json;
        const Match matches[5];
      } cases[] = {
        // A deletion URL on a personalized query should be reflected in the
        // resulting AutocompleteMatch.
        { "a",
          "[\"a\",[\"ab\", \"ac\",\"www.amazon.com\"],[],[],"
@@ skipping 39 matching lines @@
          { { "a", "", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED },
            { "ac", "", AutocompleteMatchType::SEARCH_SUGGEST },
            { "ab", "", AutocompleteMatchType::SEARCH_SUGGEST },
            { "www.amazon.com", "",
               AutocompleteMatchType::NAVSUGGEST_PERSONALIZED },
            kEmptyMatch,
          },
        },
      };
 
-     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
-       QueryForInput(ASCIIToUTF16(cases[i].input_text), false, false);
-
-       net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
-           SearchProvider::kDefaultProviderURLFetcherID);
-       ASSERT_TRUE(fetcher);
-       fetcher->set_response_code(200);
-       fetcher->SetResponseString(cases[i].response_json);
-       fetcher->delegate()->OnURLFetchComplete(fetcher);
-
-       RunTillProviderDone();
+     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+       QueryForInputAndWaitForFetcherResponses(
+           ASCIIToUTF16(cases[i].input_text), false, cases[i].response_json,
+           std::string());
 
        const ACMatches& matches = provider_->matches();
        ASSERT_FALSE(matches.empty());
 
        SCOPED_TRACE("for input with json = " + cases[i].response_json);
 
        for (size_t j = 0; j < matches.size(); ++j) {
          const Match& match = cases[i].matches[j];
          SCOPED_TRACE(" and match index: " + base::IntToString(j));
          EXPECT_EQ(match.contents, base::UTF16ToUTF8(matches[j].contents));
@@ skipping 214 matching lines @@
   EXPECT_FALSE(FindMatchWithContents(ASCIIToUTF16("flash games"), &games));
 }
 
 // Verifies that duplicates are preserved in AddMatchToMap().
 TEST_F(SearchProviderTest, CheckDuplicateMatchesSaved) {
   AddSearchToHistory(default_t_url_, ASCIIToUTF16("a"), 1);
   AddSearchToHistory(default_t_url_, ASCIIToUTF16("alpha"), 1);
   AddSearchToHistory(default_t_url_, ASCIIToUTF16("avid"), 1);
 
   profile_.BlockUntilHistoryProcessesPendingRequests();
-  QueryForInput(ASCIIToUTF16("a"), false, false);
-
-  // Make sure the default provider's suggest service was queried.
-  net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
-      SearchProvider::kDefaultProviderURLFetcherID);
-  ASSERT_TRUE(fetcher);
-
-  // Tell the SearchProvider the suggest query is done.
-  fetcher->set_response_code(200);
-  fetcher->SetResponseString(
+  QueryForInputAndWaitForFetcherResponses(
+      ASCIIToUTF16("a"), false,
       "[\"a\",[\"a\", \"alpha\", \"avid\", \"apricot\"],[],[],"
       "{\"google:suggestrelevance\":[1450, 1200, 1150, 1100],"
-      "\"google:verbatimrelevance\":1350}]");
-  fetcher->delegate()->OnURLFetchComplete(fetcher);
-  fetcher = NULL;
-
-  // Run till the history results complete.
-  RunTillProviderDone();
+      "\"google:verbatimrelevance\":1350}]",
+      std::string());
 
   AutocompleteMatch verbatim, match_alpha, match_apricot, match_avid;
   EXPECT_TRUE(FindMatchWithContents(ASCIIToUTF16("a"), &verbatim));
   EXPECT_TRUE(FindMatchWithContents(ASCIIToUTF16("alpha"), &match_alpha));
   EXPECT_TRUE(FindMatchWithContents(ASCIIToUTF16("apricot"), &match_apricot));
   EXPECT_TRUE(FindMatchWithContents(ASCIIToUTF16("avid"), &match_avid));
 
   // Verbatim match duplicates are added such that each one has a higher
   // relevance than the previous one.
   EXPECT_EQ(2U, verbatim.duplicate_matches.size());
@@ skipping 95 matching lines @@
   AutocompleteInput input(base::ASCIIToUTF16("weather l"),
                           base::string16::npos, base::string16(), GURL(),
                           metrics::OmniboxEventProto::INVALID_SPEC, false,
                           false, true, true,
                           ChromeAutocompleteSchemeClassifier(&profile_));
   provider_->DoAnswersQuery(input);
   EXPECT_EQ(base::ASCIIToUTF16("weather los angeles"),
             provider_->prefetch_data_.full_query_text);
   EXPECT_EQ(base::ASCIIToUTF16("2334"), provider_->prefetch_data_.query_type);
 }