Remove NOTIFICATION_HISTORY_URLS_DELETED

chrome/browser/history/history_backend_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/history/history_backend.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/in_memory_history_backend.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/importer/imported_favicon_usage.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/history/core/browser/history_constants.h"
 #include "components/history/core/browser/history_database_params.h"
+#include "components/history/core/browser/history_service_observer.h"
 #include "components/history/core/browser/in_memory_database.h"
 #include "components/history/core/browser/keyword_search_term.h"
 #include "components/history/core/browser/visit_filter.h"
 #include "components/history/core/test/history_client_fake_bookmarks.h"
 #include "components/history/core/test/test_history_database.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/notification_source.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "url/gurl.h"
 
 using base::Time;
 
 // This file only tests functionality where it is most convenient to call the
@@ skipping 69 matching lines @@
 
   void NotifyProfileError(sql::InitStatus init_status) override {}
   void SetInMemoryBackend(scoped_ptr<InMemoryHistoryBackend> backend) override;
   void NotifyAddVisit(const BriefVisitInfo& info) override {}
   void NotifyFaviconChanged(const std::set<GURL>& urls) override;
   void NotifyURLVisited(ui::PageTransition transition,
                         const URLRow& row,
                         const RedirectList& redirects,
                         base::Time visit_time) override;
   void NotifyURLsModified(const URLRows& changed_urls) override;
+  void NotifyURLsDeleted(bool all_history,
+                         bool expired,
+                         const URLRows& deleted_rows,
+                         const std::set<GURL>& favicon_urls) override;
   void NotifyKeywordSearchTermUpdated(const URLRow& row,
                                       KeywordID keyword_id,
                                       const base::string16& term) override;
   void NotifyKeywordSearchTermDeleted(URLID url_id) override;
-  void BroadcastNotifications(int type,
-                              scoped_ptr<HistoryDetails> details) override;
   void DBLoaded() override;
 
  private:
   // Not owned by us.
   HistoryBackendTestBase* test_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryBackendTestDelegate);
 };
 
 class HistoryBackendTestBase : public testing::Test {
  public:
-  typedef std::vector<std::pair<int, HistoryDetails*> > NotificationList;
   typedef std::vector<std::pair<ui::PageTransition, URLRow>> URLVisitedList;
   typedef std::vector<URLRows> URLsModifiedList;
+  typedef std::vector<std::pair<bool, bool>> URLsDeletedList;
 
   HistoryBackendTestBase()
       : loaded_(false),
         favicon_changed_notifications_(0),
         ui_thread_(content::BrowserThread::UI, &message_loop_) {}
 
   ~HistoryBackendTestBase() override {
-    STLDeleteValues(&broadcasted_notifications_);
   }
 
  protected:
   int favicon_changed_notifications() const {
     return favicon_changed_notifications_;
   }
 
   void ClearFaviconChangedNotificationCounter() {
     favicon_changed_notifications_ = 0;
   }
 
   int num_url_visited_notifications() const {
     return url_visited_notifications_.size();
   }
 
   const URLVisitedList& url_visited_notifications() const {
     return url_visited_notifications_;
   }
 
   int num_urls_modified_notifications() const {
     return urls_modified_notifications_.size();
   }
 
   const URLsModifiedList& urls_modified_notifications() const {
     return urls_modified_notifications_;
   }
 
-  int num_broadcasted_notifications() const {
-    return broadcasted_notifications_.size();
-  }
-
-  const NotificationList& broadcasted_notifications() const {
-    return broadcasted_notifications_;
+  const URLsDeletedList& urls_deleted_notifications() const {
+    return urls_deleted_notifications_;
   }
 
   void ClearBroadcastedNotifications() {
     url_visited_notifications_.clear();
     urls_modified_notifications_.clear();
-    STLDeleteValues(&broadcasted_notifications_);
+    urls_deleted_notifications_.clear();
   }
 
   base::FilePath test_dir() {
     return test_dir_;
   }
 
   void NotifyFaviconChanged(const std::set<GURL>& changed_favicons) {
     ++favicon_changed_notifications_;
   }
 
   void NotifyURLVisited(ui::PageTransition transition,
                         const URLRow& row,
                         const RedirectList& redirects,
                         base::Time visit_time) {
     // Send the notifications directly to the in-memory database.
     mem_backend_->OnURLVisited(nullptr, transition, row, redirects, visit_time);
     url_visited_notifications_.push_back(std::make_pair(transition, row));
   }
 
   void NotifyURLsModified(const URLRows& changed_urls) {
     // Send the notifications directly to the in-memory database.
     mem_backend_->OnURLsModified(nullptr, changed_urls);
     urls_modified_notifications_.push_back(changed_urls);
   }
 
+  void NotifyURLsDeleted(bool all_history,
+                         bool expired,
+                         const URLRows& deleted_rows,
+                         const std::set<GURL>& favicon_urls) {
+    mem_backend_->OnURLsDeleted(nullptr, all_history, expired, deleted_rows,
+                                favicon_urls);
+    urls_deleted_notifications_.push_back(std::make_pair(all_history, expired));
+  }
+
   void NotifyKeywordSearchTermUpdated(const URLRow& row,
                                       KeywordID keyword_id,
                                       const base::string16& term) {
     mem_backend_->OnKeywordSearchTermUpdated(nullptr, row, keyword_id, term);
   }
 
   void NotifyKeywordSearchTermDeleted(URLID url_id) {
     mem_backend_->OnKeywordSearchTermDeleted(nullptr, url_id);
   }
 
-  void BroadcastNotifications(int type, scoped_ptr<HistoryDetails> details) {
-    // Send the notifications directly to the in-memory database.
-    content::Details<HistoryDetails> det(details.get());
-    mem_backend_->Observe(
-        type, content::Source<HistoryBackendTestBase>(NULL), det);
-
-    // The backend passes ownership of the details pointer to us.
-    broadcasted_notifications_.push_back(
-        std::make_pair(type, details.release()));
-  }
-
   history::HistoryClientFakeBookmarks history_client_;
   scoped_refptr<HistoryBackend> backend_;  // Will be NULL on init failure.
   scoped_ptr<InMemoryHistoryBackend> mem_backend_;
   bool loaded_;
 
  private:
   friend class HistoryBackendTestDelegate;
 
   // testing::Test
   void SetUp() override {
@@ skipping 15 matching lines @@
     base::DeleteFile(test_dir_, true);
     base::RunLoop().RunUntilIdle();
     history_client_.ClearAllBookmarks();
   }
 
   void SetInMemoryBackend(scoped_ptr<InMemoryHistoryBackend> backend) {
     mem_backend_.swap(backend);
   }
 
   // The types and details of notifications which were broadcasted.
-  NotificationList broadcasted_notifications_;
   int favicon_changed_notifications_;
   URLVisitedList url_visited_notifications_;
   URLsModifiedList urls_modified_notifications_;
+  URLsDeletedList urls_deleted_notifications_;
 
   base::MessageLoop message_loop_;
   base::FilePath test_dir_;
   content::TestBrowserThread ui_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryBackendTestBase);
 };
 
 void HistoryBackendTestDelegate::SetInMemoryBackend(
     scoped_ptr<InMemoryHistoryBackend> backend) {
@@ skipping 10 matching lines @@
                                                   const RedirectList& redirects,
                                                   base::Time visit_time) {
   test_->NotifyURLVisited(transition, row, redirects, visit_time);
 }
 
 void HistoryBackendTestDelegate::NotifyURLsModified(
     const URLRows& changed_urls) {
   test_->NotifyURLsModified(changed_urls);
 }
 
+void HistoryBackendTestDelegate::NotifyURLsDeleted(
+    bool all_history,
+    bool expired,
+    const URLRows& deleted_rows,
+    const std::set<GURL>& favicon_urls) {
+  test_->NotifyURLsDeleted(all_history, expired, deleted_rows, favicon_urls);
+}
+
 void HistoryBackendTestDelegate::NotifyKeywordSearchTermUpdated(
     const URLRow& row,
     KeywordID keyword_id,
     const base::string16& term) {
   test_->NotifyKeywordSearchTermUpdated(row, keyword_id, term);
 }
 
 void HistoryBackendTestDelegate::NotifyKeywordSearchTermDeleted(URLID url_id) {
   test_->NotifyKeywordSearchTermDeleted(url_id);
 }
 
-void HistoryBackendTestDelegate::BroadcastNotifications(
-    int type,
-    scoped_ptr<HistoryDetails> details) {
-  test_->BroadcastNotifications(type, details.Pass());
-}
-
 void HistoryBackendTestDelegate::DBLoaded() {
   test_->loaded_ = true;
 }
 
 class HistoryBackendTest : public HistoryBackendTestBase {
  public:
   HistoryBackendTest() {}
   ~HistoryBackendTest() override {}
 
  protected:
@@ skipping 147 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(HistoryBackendTest);
 };
 
 class InMemoryHistoryBackendTest : public HistoryBackendTestBase {
  public:
   InMemoryHistoryBackendTest() {}
   ~InMemoryHistoryBackendTest() override {}
 
  protected:
-  void SimulateNotification(int type,
-                            const URLRow* row1,
-                            const URLRow* row2 = NULL,
-                            const URLRow* row3 = NULL) {
-    DCHECK(type == chrome::NOTIFICATION_HISTORY_URLS_DELETED);
-
+  void SimulateNotificationURLsDeleted(const URLRow* row1,
+                                       const URLRow* row2 = NULL,
+                                       const URLRow* row3 = NULL) {
     URLRows rows;
     rows.push_back(*row1);
     if (row2) rows.push_back(*row2);
     if (row3) rows.push_back(*row3);
 
-    scoped_ptr<URLsDeletedDetails> details(new URLsDeletedDetails());
-    details->rows = rows;
-    BroadcastNotifications(type, details.Pass());
+    NotifyURLsDeleted(false, false, rows, std::set<GURL>());
   }
 
   size_t GetNumberOfMatchingSearchTerms(const int keyword_id,
                                         const base::string16& prefix) {
     std::vector<KeywordSearchTermVisit> matching_terms;
     mem_backend_->db()->GetMostRecentKeywordSearchTerms(
         keyword_id, prefix, 1, &matching_terms);
     return matching_terms.size();
   }
 
@@ skipping 182 matching lines @@
   std::vector<IconMapping> mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       outrow1.url(), favicon_base::FAVICON, &mappings));
   EXPECT_EQ(1u, mappings.size());
   EXPECT_EQ(out_favicon1, mappings[0].icon_id);
 
   // The first URL should still be bookmarked.
   EXPECT_TRUE(history_client_.IsBookmarked(row1.url()));
 
   // Check that we fire the notification about all history having been deleted.
-  ASSERT_EQ(1u, broadcasted_notifications().size());
-  ASSERT_EQ(chrome::NOTIFICATION_HISTORY_URLS_DELETED,
-            broadcasted_notifications()[0].first);
-  const URLsDeletedDetails* details = static_cast<const URLsDeletedDetails*>(
-      broadcasted_notifications()[0].second);
-  EXPECT_TRUE(details->all_history);
-  EXPECT_FALSE(details->expired);
+  ASSERT_EQ(1u, urls_deleted_notifications().size());
+  EXPECT_TRUE(urls_deleted_notifications()[0].first);
+  EXPECT_FALSE(urls_deleted_notifications()[0].second);
 }
 
 // Checks that adding a visit, then calling DeleteAll, and then trying to add
 // data for the visited page works.  This can happen when clearing the history
 // immediately after visiting a page.
 TEST_F(HistoryBackendTest, DeleteAllThenAddData) {
   ASSERT_TRUE(backend_.get());
 
   Time visit_time = Time::Now();
   GURL url("http://www.google.com/");
@@ skipping 2429 matching lines @@
 
 TEST_F(InMemoryHistoryBackendTest, OnURLsDeletedPiecewise) {
   // Add two typed and one non-typed URLRow to the in-memory database.
   URLRow row1(CreateTestTypedURL());
   URLRow row2(CreateAnotherTestTypedURL());
   URLRow row3(CreateTestNonTypedURL());
   SimulateNotificationURLsModified(mem_backend_.get(), &row1, &row2, &row3);
 
   // Notify the in-memory database that the second typed URL and the non-typed
   // URL has been deleted.
-  SimulateNotification(chrome::NOTIFICATION_HISTORY_URLS_DELETED,
-                       &row2, &row3);
+  SimulateNotificationURLsDeleted(&row2, &row3);
 
   // Expect that the first typed URL remains intact, the second typed URL is
   // correctly removed, and the non-typed URL does not magically appear.
   URLRow cached_row1;
   EXPECT_NE(0, mem_backend_->db()->GetRowForURL(row1.url(), &cached_row1));
   EXPECT_EQ(0, mem_backend_->db()->GetRowForURL(row2.url(), NULL));
   EXPECT_EQ(0, mem_backend_->db()->GetRowForURL(row3.url(), NULL));
   EXPECT_EQ(row1.id(), cached_row1.id());
 }
 
 TEST_F(InMemoryHistoryBackendTest, OnURLsDeletedEnMasse) {
   // Add two typed and one non-typed URLRow to the in-memory database.
   URLRow row1(CreateTestTypedURL());
   URLRow row2(CreateAnotherTestTypedURL());
   URLRow row3(CreateTestNonTypedURL());
   SimulateNotificationURLsModified(mem_backend_.get(), &row1, &row2, &row3);
 
   // Now notify the in-memory database that all history has been deleted.
-  scoped_ptr<URLsDeletedDetails> details(new URLsDeletedDetails());
-  details->all_history = true;
-  BroadcastNotifications(chrome::NOTIFICATION_HISTORY_URLS_DELETED,
-                         details.Pass());
+  mem_backend_->OnURLsDeleted(nullptr, true, false, URLRows(),
+                              std::set<GURL>());
 
   // Expect that everything goes away.
   EXPECT_EQ(0, mem_backend_->db()->GetRowForURL(row1.url(), NULL));
   EXPECT_EQ(0, mem_backend_->db()->GetRowForURL(row2.url(), NULL));
   EXPECT_EQ(0, mem_backend_->db()->GetRowForURL(row3.url(), NULL));
 }
 
 void InMemoryHistoryBackendTest::PopulateTestURLsAndSearchTerms(
     URLRow* row1,
     URLRow* row2,
@@ skipping 89 matching lines @@
 }
 
 TEST_F(InMemoryHistoryBackendTest, OnURLsDeletedWithSearchTerms) {
   URLRow row1(CreateTestTypedURL());
   URLRow row2(CreateTestNonTypedURL());
   base::string16 term1(base::UTF8ToUTF16(kTestSearchTerm1));
   base::string16 term2(base::UTF8ToUTF16(kTestSearchTerm2));
   PopulateTestURLsAndSearchTerms(&row1, &row2, term1, term2);
 
   // Notify the in-memory database that the second typed URL has been deleted.
-  SimulateNotification(chrome::NOTIFICATION_HISTORY_URLS_DELETED, &row2);
+  SimulateNotificationURLsDeleted(&row2);
 
   // Verify that the second term is no longer returned as result, and also check
   // at the low level that it is gone for good. The term corresponding to the
   // first URLRow should not be affected.
   EXPECT_EQ(1u, GetNumberOfMatchingSearchTerms(kTestKeywordId, term1));
   EXPECT_EQ(0u, GetNumberOfMatchingSearchTerms(kTestKeywordId, term2));
   EXPECT_TRUE(mem_backend_->db()->GetKeywordSearchTermRow(row1.id(), NULL));
   EXPECT_FALSE(mem_backend_->db()->GetKeywordSearchTermRow(row2.id(), NULL));
 }
 
 }  // namespace history