Remove NOTIFICATION_HISTORY_URLS_MODIFIED

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>
 
@@ skipping 71 matching lines @@
     rows.push_back(*row3);
 
   base::Time visit_time;
   history::RedirectList redirects;
   for (const auto& row : rows) {
     observer->OnURLVisited(
         nullptr, ui::PAGE_TRANSITION_LINK, row, redirects, visit_time);
   }
 }
 
+void SimulateNotificationURLsModified(history::HistoryServiceObserver* observer,
+                                      const history::URLRow* row1,
+                                      const history::URLRow* row2,
+                                      const history::URLRow* row3) {
+  history::URLRows rows;
+  rows.push_back(*row1);
+  if (row2)
+    rows.push_back(*row2);
+  if (row3)
+    rows.push_back(*row3);
+
+  observer->OnURLsModified(nullptr, rows);
+}
+
 }  // namespace
 
 namespace history {
 
 class HistoryBackendTestBase;
 
 // This must be a separate object since HistoryBackend manages its lifetime.
 // This just forwards the messages we're interested in to the test object.
 class HistoryBackendTestDelegate : public HistoryBackend::Delegate {
  public:
   explicit HistoryBackendTestDelegate(HistoryBackendTestBase* test)
       : test_(test) {}
 
   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 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;
 
   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_;
   }
 
   void ClearBroadcastedNotifications() {
     url_visited_notifications_.clear();
+    urls_modified_notifications_.clear();
     STLDeleteValues(&broadcasted_notifications_);
   }
 
   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 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()));
   }
@@ skipping 28 matching lines @@
   }
 
   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_;
 
   base::MessageLoop message_loop_;
   base::FilePath test_dir_;
   content::TestBrowserThread ui_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryBackendTestBase);
 };
 
 void HistoryBackendTestDelegate::SetInMemoryBackend(
     scoped_ptr<InMemoryHistoryBackend> backend) {
   test_->SetInMemoryBackend(backend.Pass());
 }
 
 void HistoryBackendTestDelegate::NotifyFaviconChanged(
     const std::set<GURL>& changed_favicons) {
   test_->NotifyFaviconChanged(changed_favicons);
 }
 
 void HistoryBackendTestDelegate::NotifyURLVisited(ui::PageTransition transition,
                                                   const URLRow& row,
                                                   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::BroadcastNotifications(
     int type,
     scoped_ptr<HistoryDetails> details) {
   test_->BroadcastNotifications(type, details.Pass());
 }
 
 void HistoryBackendTestDelegate::DBLoaded() {
   test_->loaded_ = true;
 }
 
@@ skipping 152 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HistoryBackendTest);
 };
 
 class InMemoryHistoryBackendTest : public HistoryBackendTestBase {
  public:
   InMemoryHistoryBackendTest() {}
   ~InMemoryHistoryBackendTest() override {}
 
-  // Public so that the method can be bound in test fixture using
-  // base::Bind(&InMemoryHistoryBackendTest::SimulateNotification, ...).
+ protected:
   void SimulateNotification(int type,
                             const URLRow* row1,
                             const URLRow* row2 = NULL,
                             const URLRow* row3 = NULL) {
+    DCHECK(type == chrome::NOTIFICATION_HISTORY_URLS_DELETED);
+
     URLRows rows;
     rows.push_back(*row1);
     if (row2) rows.push_back(*row2);
     if (row3) rows.push_back(*row3);
 
-    if (type == chrome::NOTIFICATION_HISTORY_URLS_MODIFIED) {
-      scoped_ptr<URLsModifiedDetails> details(new URLsModifiedDetails());
-      details->changed_urls.swap(rows);
-      BroadcastNotifications(type, details.Pass());
-    } else if (type == chrome::NOTIFICATION_HISTORY_URLS_DELETED) {
-      scoped_ptr<URLsDeletedDetails> details(new URLsDeletedDetails());
-      details->rows = rows;
-      BroadcastNotifications(type, details.Pass());
-    } else {
-      NOTREACHED();
-    }
+    scoped_ptr<URLsDeletedDetails> details(new URLsDeletedDetails());
+    details->rows = rows;
+    BroadcastNotifications(type, details.Pass());
   }
 
- protected:
   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();
   }
 
   static URLRow CreateTestTypedURL() {
     URLRow url_row(GURL("https://www.google.com/"));
@@ skipping 449 matching lines @@
   URLRow stored_row1, stored_row2, stored_row3, stored_row4;
   EXPECT_NE(0, backend_->db_->GetRowForURL(row1.url(), &stored_row1));
   EXPECT_NE(0, backend_->db_->GetRowForURL(row2.url(), &stored_row2));
   EXPECT_NE(0, backend_->db_->GetRowForURL(row3.url(), &stored_row3));
   EXPECT_EQ(0, backend_->db_->GetRowForURL(row4.url(), &stored_row4));
 
   // Ensure that a notification was fired for both typed and non-typed URLs.
   // Further verify that the IDs in the notification are set to those that are
   // in effect in the main database. The InMemoryHistoryBackend relies on this
   // for caching.
-  ASSERT_EQ(1u, broadcasted_notifications().size());
-  ASSERT_EQ(chrome::NOTIFICATION_HISTORY_URLS_MODIFIED,
-            broadcasted_notifications()[0].first);
-  const URLsModifiedDetails* details = static_cast<const URLsModifiedDetails*>(
-      broadcasted_notifications()[0].second);
-  EXPECT_EQ(3u, details->changed_urls.size());
+  ASSERT_EQ(1, num_urls_modified_notifications());
 
-  URLRows::const_iterator it_row1 = std::find_if(
-      details->changed_urls.begin(),
-      details->changed_urls.end(),
-      history::URLRow::URLRowHasURL(row1.url()));
-  ASSERT_NE(details->changed_urls.end(), it_row1);
+  const URLRows& changed_urls = urls_modified_notifications()[0];
+  EXPECT_EQ(3u, changed_urls.size());
+
+  URLRows::const_iterator it_row1 =
+      std::find_if(changed_urls.begin(),
+                   changed_urls.end(),
+                   history::URLRow::URLRowHasURL(row1.url()));
+  ASSERT_NE(changed_urls.end(), it_row1);
   EXPECT_EQ(stored_row1.id(), it_row1->id());
 
-  URLRows::const_iterator it_row2 = std::find_if(
-        details->changed_urls.begin(),
-        details->changed_urls.end(),
-        history::URLRow::URLRowHasURL(row2.url()));
-  ASSERT_NE(details->changed_urls.end(), it_row2);
+  URLRows::const_iterator it_row2 =
+      std::find_if(changed_urls.begin(),
+                   changed_urls.end(),
+                   history::URLRow::URLRowHasURL(row2.url()));
+  ASSERT_NE(changed_urls.end(), it_row2);
   EXPECT_EQ(stored_row2.id(), it_row2->id());
 
-  URLRows::const_iterator it_row3 = std::find_if(
-        details->changed_urls.begin(),
-        details->changed_urls.end(),
-        history::URLRow::URLRowHasURL(row3.url()));
-  ASSERT_NE(details->changed_urls.end(), it_row3);
+  URLRows::const_iterator it_row3 =
+      std::find_if(changed_urls.begin(),
+                   changed_urls.end(),
+                   history::URLRow::URLRowHasURL(row3.url()));
+  ASSERT_NE(changed_urls.end(), it_row3);
   EXPECT_EQ(stored_row3.id(), it_row3->id());
 }
 
 TEST_F(HistoryBackendTest, UpdateURLs) {
   ASSERT_TRUE(backend_.get());
 
   // Add three pages directly to the database.
   URLRow row1(GURL("https://news.google.com/"));
   row1.set_visit_count(1);
   row1.set_last_visit(Time::Now());
@@ skipping 30 matching lines @@
 
   URLRow stored_row1, stored_row3;
   EXPECT_NE(0, backend_->db_->GetRowForURL(row1.url(), &stored_row1));
   EXPECT_NE(0, backend_->db_->GetRowForURL(row3.url(), &stored_row3));
   EXPECT_EQ(altered_row1.visit_count(), stored_row1.visit_count());
   EXPECT_EQ(altered_row3.visit_count(), stored_row3.visit_count());
 
   // Ensure that a notification was fired, and further verify that the IDs in
   // the notification are set to those that are in effect in the main database.
   // The InMemoryHistoryBackend relies on this for caching.
-  ASSERT_EQ(1u, broadcasted_notifications().size());
-  ASSERT_EQ(chrome::NOTIFICATION_HISTORY_URLS_MODIFIED,
-            broadcasted_notifications()[0].first);
-  const URLsModifiedDetails* details = static_cast<const URLsModifiedDetails*>(
-      broadcasted_notifications()[0].second);
-  EXPECT_EQ(2u, details->changed_urls.size());
+  ASSERT_EQ(1, num_urls_modified_notifications());
+
+  const URLRows& changed_urls = urls_modified_notifications()[0];
+  EXPECT_EQ(2u, changed_urls.size());
 
   URLRows::const_iterator it_row1 =
-      std::find_if(details->changed_urls.begin(),
-                   details->changed_urls.end(),
+      std::find_if(changed_urls.begin(),
+                   changed_urls.end(),
                    history::URLRow::URLRowHasURL(row1.url()));
-  ASSERT_NE(details->changed_urls.end(), it_row1);
+  ASSERT_NE(changed_urls.end(), it_row1);
   EXPECT_EQ(altered_row1.id(), it_row1->id());
   EXPECT_EQ(altered_row1.visit_count(), it_row1->visit_count());
 
   URLRows::const_iterator it_row3 =
-      std::find_if(details->changed_urls.begin(),
-                   details->changed_urls.end(),
+      std::find_if(changed_urls.begin(),
+                   changed_urls.end(),
                    history::URLRow::URLRowHasURL(row3.url()));
-  ASSERT_NE(details->changed_urls.end(), it_row3);
+  ASSERT_NE(changed_urls.end(), it_row3);
   EXPECT_EQ(altered_row3.id(), it_row3->id());
   EXPECT_EQ(altered_row3.visit_count(), it_row3->visit_count());
 }
 
 // This verifies that a notification is fired. In-depth testing of logic should
 // be done in HistoryTest.SetTitle.
 TEST_F(HistoryBackendTest, SetPageTitleFiresNotificationWithCorrectDetails) {
   const char kTestUrlTitle[] = "Google Search";
 
   ASSERT_TRUE(backend_.get());
@@ skipping 12 matching lines @@
   backend_->AddPagesWithDetails(rows, history::SOURCE_BROWSED);
 
   ClearBroadcastedNotifications();
   backend_->SetPageTitle(row2.url(), base::UTF8ToUTF16(kTestUrlTitle));
 
   // Ensure that a notification was fired, and further verify that the IDs in
   // the notification are set to those that are in effect in the main database.
   // The InMemoryHistoryBackend relies on this for caching.
   URLRow stored_row2;
   EXPECT_TRUE(backend_->GetURL(row2.url(), &stored_row2));
-  ASSERT_EQ(1u, broadcasted_notifications().size());
-  ASSERT_EQ(chrome::NOTIFICATION_HISTORY_URLS_MODIFIED,
-            broadcasted_notifications()[0].first);
-  const URLsModifiedDetails* details = static_cast<const URLsModifiedDetails*>(
-      broadcasted_notifications()[0].second);
-  ASSERT_EQ(1u, details->changed_urls.size());
-  EXPECT_EQ(base::UTF8ToUTF16(kTestUrlTitle), details->changed_urls[0].title());
-  EXPECT_EQ(stored_row2.id(), details->changed_urls[0].id());
+  ASSERT_EQ(1, num_urls_modified_notifications());
+
+  const URLRows& changed_urls = urls_modified_notifications()[0];
+  ASSERT_EQ(1u, changed_urls.size());
+  EXPECT_EQ(base::UTF8ToUTF16(kTestUrlTitle), changed_urls[0].title());
+  EXPECT_EQ(stored_row2.id(), changed_urls[0].id());
 }
 
 // There's no importer on Android.
 #if !defined(OS_ANDROID)
 TEST_F(HistoryBackendTest, ImportedFaviconsTest) {
   // Setup test data - two Urls in the history, one with favicon assigned and
   // one without.
   GURL favicon_url1("http://www.google.com/favicon.ico");
   std::vector<unsigned char> data;
   data.push_back('1');
@@ skipping 2018 matching lines @@
   // The in-memory database should stop caching the first URLRow, and start
   // caching the second URLRow.
   EXPECT_EQ(0, mem_backend_->db()->GetRowForURL(row1.url(), &cached_row1));
   EXPECT_NE(0, mem_backend_->db()->GetRowForURL(row2.url(), &cached_row2));
   EXPECT_EQ(row2.id(), cached_row2.id());
   EXPECT_EQ(base::UTF8ToUTF16(kTestNonTypedURLAlternativeTitle),
             cached_row2.title());
 }
 
 TEST_F(InMemoryHistoryBackendTest, OnURLsModified) {
-  TestAddingAndChangingURLRows(
-      base::Bind(&InMemoryHistoryBackendTest::SimulateNotification,
-                 base::Unretained(this),
-                 chrome::NOTIFICATION_HISTORY_URLS_MODIFIED));
+  TestAddingAndChangingURLRows(base::Bind(
+      &SimulateNotificationURLsModified, base::Unretained(mem_backend_.get())));
 }
 
 TEST_F(InMemoryHistoryBackendTest, OnURLsVisisted) {
   TestAddingAndChangingURLRows(base::Bind(
       &SimulateNotificationURLVisited, base::Unretained(mem_backend_.get())));
 }
 
 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());
-  SimulateNotification(chrome::NOTIFICATION_HISTORY_URLS_MODIFIED,
-                       &row1, &row2, &row3);
+  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);
 
   // 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());
-  SimulateNotification(chrome::NOTIFICATION_HISTORY_URLS_MODIFIED,
-                       &row1, &row2, &row3);
+  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());
 
   // 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));
@@ skipping 107 matching lines @@
   // 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