HistoryQuickProviderTest.DeleteMatch thread safety fix.

chrome/browser/autocomplete/history_quick_provider_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/omnibox/browser/history_quick_provider.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <string>
@@ skipping 190 matching lines @@
 
   // As above, simply with a cursor position specified.
   void RunTestWithCursor(const base::string16 text,
                          const size_t cursor_position,
                          bool prevent_inline_autocomplete,
                          std::vector<std::string> expected_urls,
                          bool can_inline_top_result,
                          base::string16 expected_fill_into_edit,
                          base::string16 autocompletion);
 
+  // TODO(shess): From history_service.h in reference to history_backend:
+  // > This class has most of the implementation and runs on the 'thread_'.
+  // > You MUST communicate with this class ONLY through the thread_'s
+  // > message_loop().
+  // Direct use of this object in tests is almost certainly not thread-safe.
   history::HistoryBackend* history_backend() {
     return history_service_->history_backend_.get();
   }
 
+  // Call history_backend()->GetURL(url, NULL) on the history thread, returning
+  // the result.
+  bool GetURLProxy(const GURL& url);
+
+  // Background task posted by GetURLProxy().
+  static void GetURLTask(history::HistoryBackend* backend,
+                         const GURL& url,
+                         bool* result_storage);
+
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<ChromeAutocompleteProviderClient> client_;
   history::HistoryService* history_service_;
 
   ACMatches ac_matches_;  // The resulting matches after running RunTest.
 
@@ skipping 162 matching lines @@
       << "), we noticed scores are not monotonically decreasing.";
     best_score = actual->relevance;
   }
 
   EXPECT_EQ(can_inline_top_result, ac_matches_[0].allowed_to_be_default_match);
   if (can_inline_top_result)
     EXPECT_EQ(expected_autocompletion, ac_matches_[0].inline_autocompletion);
   EXPECT_EQ(expected_fill_into_edit, ac_matches_[0].fill_into_edit);
 }
 
+bool HistoryQuickProviderTest::GetURLProxy(const GURL& url) {
+  bool result = false;
+  base::RunLoop runner;
+  history_service_->PostTaskAndReplyForTest(
+      base::Bind(&GetURLTask, base::Unretained(history_backend()),
+                 url, &result),
+      runner.QuitClosure());
+  runner.Run();
+  return result;
+}
+
+// static
+void HistoryQuickProviderTest::GetURLTask(history::HistoryBackend* backend,
+                                          const GURL& url,
+                                          bool* result_storage) {
+  *result_storage = backend->GetURL(url, NULL);
+}
+
 TEST_F(HistoryQuickProviderTest, SimpleSingleMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://slashdot.org/favorite_page.html");
   RunTest(ASCIIToUTF16("slashdot"), false, expected_urls, true,
           ASCIIToUTF16("slashdot.org/favorite_page.html"),
                   ASCIIToUTF16(".org/favorite_page.html"));
 }
 
 TEST_F(HistoryQuickProviderTest, SingleMatchWithCursor) {
   std::vector<std::string> expected_urls;
@@ skipping 202 matching lines @@
 
 TEST_F(HistoryQuickProviderTest, DeleteMatch) {
   GURL test_url("http://slashdot.org/favorite_page.html");
   std::vector<std::string> expected_urls;
   expected_urls.push_back(test_url.spec());
   // Fill up ac_matches_; we don't really care about the test yet.
   RunTest(ASCIIToUTF16("slashdot"), false, expected_urls, true,
           ASCIIToUTF16("slashdot.org/favorite_page.html"),
                   ASCIIToUTF16(".org/favorite_page.html"));
   EXPECT_EQ(1U, ac_matches_.size());
-  EXPECT_TRUE(history_backend()->GetURL(test_url, NULL));
+  EXPECT_TRUE(GetURLProxy(test_url));
   provider_->DeleteMatch(ac_matches_[0]);
 
   // Check that the underlying URL is deleted from the history DB (this implies
   // that all visits are gone as well). Also verify that a deletion notification
   // is sent, in response to which the secondary data stores (InMemoryDatabase,
   // InMemoryURLIndex) will drop any data they might have pertaining to the URL.
   // To ensure that the deletion has been propagated everywhere before we start
   // verifying post-deletion states, first wait until we see the notification.
   WaitForURLsDeletedNotification(history_service_);
-  EXPECT_FALSE(history_backend()->GetURL(test_url, NULL));
+  EXPECT_FALSE(GetURLProxy(test_url));
 
   // Just to be on the safe side, explicitly verify that we have deleted enough
   // data so that we will not be serving the same result again.
   expected_urls.clear();
   RunTest(ASCIIToUTF16("slashdot"), false, expected_urls, true,
           ASCIIToUTF16("NONE EXPECTED"), base::string16());
 }
 
 TEST_F(HistoryQuickProviderTest, PreventBeatingURLWhatYouTypedMatch) {
   std::vector<std::string> expected_urls;
@@ skipping 190 matching lines @@
 
 TEST_F(HQPOrderingTest, TEAMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://www.teamliquid.net/");
   expected_urls.push_back("http://www.teamliquid.net/tlpd");
   expected_urls.push_back("http://www.teamliquid.net/tlpd/korean/players");
   RunTest(ASCIIToUTF16("tea"), false, expected_urls, true,
           ASCIIToUTF16("www.teamliquid.net"),
                  ASCIIToUTF16("mliquid.net"));
 }