Refactor sending NOTIFICATION_HISTORY_URL_VISITED

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"
@@ skipping 29 matching lines @@
 namespace {
 
 const int kTinyEdgeSize = 10;
 const int kSmallEdgeSize = 16;
 const int kLargeEdgeSize = 32;
 
 const gfx::Size kTinySize = gfx::Size(kTinyEdgeSize, kTinyEdgeSize);
 const gfx::Size kSmallSize = gfx::Size(kSmallEdgeSize, kSmallEdgeSize);
 const gfx::Size kLargeSize = gfx::Size(kLargeEdgeSize, kLargeEdgeSize);
 
+typedef base::Callback<void(const history::URLRow*,
+                            const history::URLRow*,
+                            const history::URLRow*)>
+    SimulateNotificationCallback;
+
 // Comparison functions as to make it easier to check results of
 // GetFaviconBitmaps() and GetIconMappingsForPageURL().
 bool IconMappingLessThan(const history::IconMapping& a,
                          const history::IconMapping& b) {
   return a.icon_url < b.icon_url;
 }
 
 bool FaviconBitmapLessThan(const history::FaviconBitmap& a,
                            const history::FaviconBitmap& b) {
   return a.pixel_size.GetArea() < b.pixel_size.GetArea();
 }
 
 class HistoryClientMock : public history::HistoryClientFakeBookmarks {
  public:
   MOCK_METHOD0(BlockUntilBookmarksLoaded, void());
 };
 
+void SimulateNotificationURLVisited(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);
+
+  base::Time visit_time;
+  history::RedirectList redirects;
+  for (const auto& row : rows) {
+    observer->OnURLVisited(
+        nullptr, ui::PAGE_TRANSITION_LINK, row, redirects, visit_time);
+  }
+}
+
 }  // 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) {}
 
   virtual void NotifyProfileError(sql::InitStatus init_status) override {}
   virtual void SetInMemoryBackend(
       scoped_ptr<InMemoryHistoryBackend> backend) override;
   virtual void NotifyAddVisit(const BriefVisitInfo& info) override {}
   virtual void NotifyFaviconChanged(const std::set<GURL>& urls) override;
+  virtual void NotifyURLVisited(ui::PageTransition transition,
+                                const URLRow& row,
+                                const RedirectList& redirects,
+                                base::Time visit_time) override;
   virtual void BroadcastNotifications(
       int type,
       scoped_ptr<HistoryDetails> details) override;
   virtual void DBLoaded() override;
 
  private:
   // Not owned by us.
   HistoryBackendTestBase* test_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryBackendTestDelegate);
@@ skipping 99 matching lines @@
 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) {
+  scoped_ptr<URLVisitedDetails> details(new URLVisitedDetails());
+  details->transition = transition;
+  details->row = row;
+  details->redirects = redirects;
+  details->visit_time = visit_time;
+  test_->BroadcastNotifications(chrome::NOTIFICATION_HISTORY_URL_VISITED,
+                                details.Pass());
+}
+
 void HistoryBackendTestDelegate::BroadcastNotifications(
     int type,
     scoped_ptr<HistoryDetails> details) {
   test_->BroadcastNotifications(type, details.Pass());
 }
 
 void HistoryBackendTestDelegate::DBLoaded() {
   test_->loaded_ = true;
 }
 
@@ skipping 147 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HistoryBackendTest);
 };
 
 class InMemoryHistoryBackendTest : public HistoryBackendTestBase {
  public:
   InMemoryHistoryBackendTest() {}
   virtual ~InMemoryHistoryBackendTest() {}
 
- protected:
+  // Public so that the method can be bound in test fixture using
+  // base::Bind(&InMemoryHistoryBackendTest::SimulateNotification, ...).
   void SimulateNotification(int type,
                             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);
 
     if (type == chrome::NOTIFICATION_HISTORY_URLS_MODIFIED) {
       scoped_ptr<URLsModifiedDetails> details(new URLsModifiedDetails());
       details->changed_urls.swap(rows);
       BroadcastNotifications(type, details.PassAs<HistoryDetails>());
     } else if (type == chrome::NOTIFICATION_HISTORY_URL_VISITED) {
       for (URLRows::const_iterator it = rows.begin(); it != rows.end(); ++it) {
         scoped_ptr<URLVisitedDetails> details(new URLVisitedDetails());
         details->row = *it;
         BroadcastNotifications(type, details.PassAs<HistoryDetails>());
       }
     } else if (type == chrome::NOTIFICATION_HISTORY_URLS_DELETED) {
       scoped_ptr<URLsDeletedDetails> details(new URLsDeletedDetails());
       details->rows = rows;
       BroadcastNotifications(type, details.PassAs<HistoryDetails>());
     } else {
       NOTREACHED();
     }
   }
 
+ 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 22 matching lines @@
     url_row.set_visit_count(5);
     url_row.set_last_visit(Time::Now() - base::TimeDelta::FromHours(3));
     return url_row;
   }
 
   void PopulateTestURLsAndSearchTerms(URLRow* row1,
                                       URLRow* row2,
                                       const base::string16& term1,
                                       const base::string16& term2);
 
-  void TestAddingAndChangingURLRows(int notification_type);
+  void TestAddingAndChangingURLRows(
+      const SimulateNotificationCallback& callback);
 
   static const KeywordID kTestKeywordId;
   static const char kTestSearchTerm1[];
   static const char kTestSearchTerm2[];
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InMemoryHistoryBackendTest);
 };
 
 const KeywordID InMemoryHistoryBackendTest::kTestKeywordId = 42;
@@ skipping 2541 matching lines @@
   EXPECT_FALSE(base::PathExists(db1));
   EXPECT_FALSE(base::PathExists(db1_wal));
   EXPECT_FALSE(base::PathExists(db1_journal));
   EXPECT_FALSE(base::PathExists(db2_symlink));
   EXPECT_TRUE(base::PathExists(db2_actual));  // Symlinks shouldn't be followed.
 }
 
 // Common implementation for the two tests below, given that the only difference
 // between them is the type of the notification sent out.
 void InMemoryHistoryBackendTest::TestAddingAndChangingURLRows(
-    int notification_type) {
+    const SimulateNotificationCallback& callback) {
   const char kTestTypedURLAlternativeTitle[] = "Google Search Again";
   const char kTestNonTypedURLAlternativeTitle[] = "Google News Again";
 
   // Notify the in-memory database that a typed and non-typed URLRow (which were
   // never before seen by the cache) have been modified.
   URLRow row1(CreateTestTypedURL());
   URLRow row2(CreateTestNonTypedURL());
-  SimulateNotification(notification_type, &row1, &row2);
+  callback.Run(&row1, &row2, nullptr);
 
   // The in-memory database should only pick up the typed URL, and should ignore
   // the non-typed one. The typed URL should retain the ID that was present in
   // the notification.
   URLRow cached_row1, cached_row2;
   EXPECT_NE(0, mem_backend_->db()->GetRowForURL(row1.url(), &cached_row1));
   EXPECT_EQ(0, mem_backend_->db()->GetRowForURL(row2.url(), &cached_row2));
   EXPECT_EQ(row1.id(), cached_row1.id());
 
   // Try changing attributes (other than typed_count) for existing URLRows.
   row1.set_title(base::UTF8ToUTF16(kTestTypedURLAlternativeTitle));
   row2.set_title(base::UTF8ToUTF16(kTestNonTypedURLAlternativeTitle));
-  SimulateNotification(notification_type, &row1, &row2);
+  callback.Run(&row1, &row2, nullptr);
 
   // URLRows that are cached by the in-memory database should be updated.
   EXPECT_NE(0, mem_backend_->db()->GetRowForURL(row1.url(), &cached_row1));
   EXPECT_EQ(0, mem_backend_->db()->GetRowForURL(row2.url(), &cached_row2));
   EXPECT_EQ(base::UTF8ToUTF16(kTestTypedURLAlternativeTitle),
             cached_row1.title());
 
   // Now decrease the typed count for the typed URLRow, and increase it for the
   // previously non-typed URLRow.
   row1.set_typed_count(0);
   row2.set_typed_count(2);
-  SimulateNotification(notification_type, &row1, &row2);
+  callback.Run(&row1, &row2, nullptr);
 
   // 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(chrome::NOTIFICATION_HISTORY_URLS_MODIFIED);
+  TestAddingAndChangingURLRows(
+      base::Bind(&InMemoryHistoryBackendTest::SimulateNotification,
+                 base::Unretained(this),
+                 chrome::NOTIFICATION_HISTORY_URLS_MODIFIED));
 }
 
 TEST_F(InMemoryHistoryBackendTest, OnURLsVisisted) {
-  TestAddingAndChangingURLRows(chrome::NOTIFICATION_HISTORY_URL_VISITED);
+  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);
 
@@ skipping 138 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