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 33 matching lines @@
 #include "content/public/test/test_utils.h"
 #include "sql/transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 using base::Time;
 using base::TimeDelta;
 
 using content::BrowserThread;
 
+namespace {
+
 struct TestURLInfo {
   std::string url;
   std::string title;
   int visit_count;
   int typed_count;
   int days_from_now;
 } quick_test_db[] = {
   {"http://www.google.com/", "Google", 3, 3, 0},
   {"http://slashdot.org/favorite_page.html", "Favorite page", 200, 100, 0},
   {"http://kerneltrap.org/not_very_popular.html", "Less popular", 4, 0, 0},
@@ skipping 79 matching lines @@
 
 void WaitForURLsDeletedNotification(history::HistoryService* history_service) {
   base::RunLoop runner;
   WaitForURLsDeletedObserver observer(&runner);
   ScopedObserver<history::HistoryService, history::HistoryServiceObserver>
       scoped_observer(&observer);
   scoped_observer.Add(history_service);
   runner.Run();
 }
 
+// Post history_backend->GetURL() to the history thread and stop the originating
+// thread's message loop when done.
+class GetURLTask : public history::HistoryDBTask {
+ public:
+  GetURLTask(const GURL& url, bool* result_storage)
+      : result_storage_(result_storage),
+        url_(url) {
+  }
+
+  bool RunOnDBThread(history::HistoryBackend* backend,
+                     history::HistoryDatabase* db) override {
+    *result_storage_ = backend->GetURL(url_, NULL);
+    return true;
+  }
+
+  void DoneRunOnMainThread() override {
+    base::MessageLoop::current()->Quit();
+  }
+
+ private:
+  ~GetURLTask() override {}
+
+  bool* result_storage_;
+  const GURL url_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetURLTask);
+};
+
+}  // namespace
+
 class HistoryQuickProviderTest : public testing::Test {
  public:
   HistoryQuickProviderTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_) {}
 
  protected:
   class SetShouldContain : public std::unary_function<const std::string&,
                                                       std::set<std::string> > {
    public:
@@ skipping 38 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);
+
   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) {
+  base::CancelableTaskTracker task_tracker;
+  bool result = false;
+  history_service_->ScheduleDBTask(
+      scoped_ptr<history::HistoryDBTask>(new GetURLTask(url, &result)),
+      &task_tracker);
+  // Run the message loop until GetURLTask::DoneRunOnMainThread stops it.  If
+  // the test hangs, DoneRunOnMainThread isn't being invoked correctly.
+  base::MessageLoop::current()->Run();
+  return result;
+}
+
 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"));
 }