Make HistoryQuickProvider::DeleteMatch also delete the underlying URL from the History Database.

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 "chrome/browser/autocomplete/history_quick_provider.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/autocomplete_provider_listener.h"
 #include "chrome/browser/autocomplete/autocomplete_result.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/in_memory_url_index.h"
 #include "chrome/browser/history/url_database.h"
 #include "chrome/browser/history/url_index_private_data.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
+#include "content/public/browser/notification_service.h"
 #include "content/public/test/test_browser_thread.h"
+#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;
 
 struct TestURLInfo {
@@ skipping 90 matching lines @@
   // Runs an autocomplete query on |text| and checks to see that the returned
   // results' destination URLs match those provided. |expected_urls| does not
   // need to be in sorted order.
   void RunTest(const base::string16 text,
                bool prevent_inline_autocomplete,
                std::vector<std::string> expected_urls,
                bool can_inline_top_result,
                base::string16 expected_fill_into_edit,
                base::string16 autocompletion);
 
+  history::HistoryBackend* history_backend() {
+    return history_service_->history_backend_;
+  }
+
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   scoped_ptr<TestingProfile> profile_;
   HistoryService* history_service_;
 
   ACMatches ac_matches_;  // The resulting matches after running RunTest.
 
   scoped_refptr<HistoryQuickProvider> provider_;
 };
 
 void HistoryQuickProviderTest::SetUp() {
   profile_.reset(new TestingProfile());
   ASSERT_TRUE(profile_->CreateHistoryService(true, false));
   profile_->CreateBookmarkModel(true);
   test::WaitForBookmarkModelToLoad(
       BookmarkModelFactory::GetForProfile(profile_.get()));
   profile_->BlockUntilHistoryIndexIsRefreshed();
   history_service_ =
       HistoryServiceFactory::GetForProfile(profile_.get(),
                                            Profile::EXPLICIT_ACCESS);
   EXPECT_TRUE(history_service_);
   provider_ = new HistoryQuickProvider(this, profile_.get());
   TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       profile_.get(), &HistoryQuickProviderTest::CreateTemplateURLService);
   FillData();
-  provider_->GetIndex()->RebuildFromHistory(
-      history_service_->history_backend_->db());
+  provider_->GetIndex()->RebuildFromHistory(history_backend()->db());
 }
 
 void HistoryQuickProviderTest::TearDown() {
   provider_ = NULL;
 }
 
 void HistoryQuickProviderTest::GetTestData(size_t* data_count,
                                            TestURLInfo** test_data) {
   DCHECK(data_count);
   DCHECK(test_data);
   *data_count = arraysize(quick_test_db);
   *test_data = &quick_test_db[0];
 }
 
 void HistoryQuickProviderTest::FillData() {
-  sql::Connection& db(history_service_->history_backend_->db()->GetDB());
+  sql::Connection& db(history_backend()->db()->GetDB());
   ASSERT_TRUE(db.is_open());
 
   size_t data_count = 0;
   TestURLInfo* test_data = NULL;
   GetTestData(&data_count, &test_data);
   size_t visit_id = 1;
   for (size_t i = 0; i < data_count; ++i) {
     const TestURLInfo& cur(test_data[i]);
     Time visit_time = Time::Now() - TimeDelta::FromDays(cur.days_from_now);
     sql::Transaction transaction(&db);
@@ skipping 296 matching lines @@
   EXPECT_EQ(ACMatchClassification::MATCH | ACMatchClassification::URL,
             spans_b[0].style);
   EXPECT_EQ(2U, spans_b[1].offset);
   EXPECT_EQ(ACMatchClassification::URL, spans_b[1].style);
   EXPECT_EQ(3U, spans_b[2].offset);
   EXPECT_EQ(ACMatchClassification::MATCH | ACMatchClassification::URL,
             spans_b[2].style);
 }
 
 TEST_F(HistoryQuickProviderTest, DeleteMatch) {
+  GURL test_url("http://slashdot.org/favorite_page.html");
   std::vector<std::string> expected_urls;
-  expected_urls.push_back("http://slashdot.org/favorite_page.html");
+  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));
   provider_->DeleteMatch(ac_matches_[0]);
   // Verify it's no longer an indexed visit.
   expected_urls.clear();
   RunTest(ASCIIToUTF16("slashdot"), false, expected_urls, true,
           ASCIIToUTF16("NONE EXPECTED"), base::string16());
+  // Verify that the underlying URL is gone from the history database -- in a
+  // consistent database, this implies that all visits must be gone as well.
+  // Also check that a notification is fired (this is also used for waiting).
+  content::WindowedNotificationObserver observer(
+      chrome::NOTIFICATION_HISTORY_URLS_DELETED,
+      content::NotificationService::AllSources());
+  observer.Wait();
+  EXPECT_FALSE(history_backend()->GetURL(test_url, NULL));
 }
 
 TEST_F(HistoryQuickProviderTest, PreventBeatingURLWhatYouTypedMatch) {
   std::vector<std::string> expected_urls;
 
   expected_urls.clear();
   expected_urls.push_back("http://popularsitewithroot.com/");
   // If the user enters a hostname (no path) that he/she has visited
   // before, we should make sure that all HistoryQuickProvider results
   // have scores less than what HistoryURLProvider will assign the
@@ skipping 176 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"));
 }