Remove 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>
 
@@ skipping 120 matching lines @@
  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;
 
   HistoryBackendTestBase()
       : loaded_(false),
         favicon_changed_notifications_(0),
         ui_thread_(content::BrowserThread::UI, &message_loop_) {}
 
   virtual ~HistoryBackendTestBase() {
     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_broadcasted_notifications() const {
     return broadcasted_notifications_.size();
   }
 
   const NotificationList& broadcasted_notifications() const {
     return broadcasted_notifications_;
   }
 
   void ClearBroadcastedNotifications() {
+    url_visited_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) {
+    url_visited_notifications_.push_back(std::make_pair(transition, row));
+  }
+
   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 27 matching lines @@
     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_;
 
   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) {
-  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());
+  test_->NotifyURLVisited(transition, row, redirects, visit_time);
 }
 
 void HistoryBackendTestDelegate::BroadcastNotifications(
     int type,
     scoped_ptr<HistoryDetails> details) {
   test_->BroadcastNotifications(type, details.Pass());
 }
 
 void HistoryBackendTestDelegate::DBLoaded() {
   test_->loaded_ = true;
@@ skipping 164 matching lines @@
                             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.Pass());
-    } 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.Pass());
-      }
     } else if (type == chrome::NOTIFICATION_HISTORY_URLS_DELETED) {
       scoped_ptr<URLsDeletedDetails> details(new URLsDeletedDetails());
       details->rows = rows;
       BroadcastNotifications(type, details.Pass());
     } else {
       NOTREACHED();
     }
   }
 
  protected:
@@ skipping 811 matching lines @@
   for (int i = 0; i < 2; ++i) {
     backend_->AddPageVisit(url2, base::Time::Now(), 0,
                            ui::PAGE_TRANSITION_TYPED,
                            history::SOURCE_BROWSED);
   }
 
   URLRow stored_row1, stored_row2;
   EXPECT_NE(0, backend_->db_->GetRowForURL(url1, &stored_row1));
   EXPECT_NE(0, backend_->db_->GetRowForURL(url2, &stored_row2));
 
-  // Expect that NOTIFICATION_HISTORY_URLS_VISITED has been fired 3x, and that
-  // each time, the URLRows have the correct URLs and IDs set.
-  ASSERT_EQ(3, num_broadcasted_notifications());
-  ASSERT_EQ(chrome::NOTIFICATION_HISTORY_URL_VISITED,
-            broadcasted_notifications()[0].first);
-  const URLVisitedDetails* details = static_cast<const URLVisitedDetails*>(
-      broadcasted_notifications()[0].second);
-  EXPECT_EQ(ui::PAGE_TRANSITION_LINK,
-            ui::PageTransitionStripQualifier(details->transition));
-  EXPECT_EQ(stored_row1.id(), details->row.id());
-  EXPECT_EQ(stored_row1.url(), details->row.url());
+  // Expect that HistoryServiceObserver::OnURLVisited has been called 3 times,
+  // and that each time the URLRows have the correct URLs and IDs set.
+  ASSERT_EQ(3, num_url_visited_notifications());
+  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(url_visited_notifications()[0].first,
+                                           ui::PAGE_TRANSITION_LINK));
+  EXPECT_EQ(stored_row1.id(), url_visited_notifications()[0].second.id());
+  EXPECT_EQ(stored_row1.url(), url_visited_notifications()[0].second.url());
 
-  // No further checking, this case analogous to the first one.
-  ASSERT_EQ(chrome::NOTIFICATION_HISTORY_URL_VISITED,
-            broadcasted_notifications()[1].first);
+  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(url_visited_notifications()[1].first,
+                                           ui::PAGE_TRANSITION_TYPED));
+  EXPECT_EQ(stored_row2.id(), url_visited_notifications()[1].second.id());
+  EXPECT_EQ(stored_row2.url(), url_visited_notifications()[1].second.url());
 
-  ASSERT_EQ(chrome::NOTIFICATION_HISTORY_URL_VISITED,
-            broadcasted_notifications()[2].first);
-  details = static_cast<const URLVisitedDetails*>(
-      broadcasted_notifications()[2].second);
-  EXPECT_EQ(ui::PAGE_TRANSITION_TYPED,
-            ui::PageTransitionStripQualifier(details->transition));
-  EXPECT_EQ(stored_row2.id(), details->row.id());
-  EXPECT_EQ(stored_row2.url(), details->row.url());
+  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(url_visited_notifications()[2].first,
+                                           ui::PAGE_TRANSITION_TYPED));
+  EXPECT_EQ(stored_row2.id(), url_visited_notifications()[2].second.id());
+  EXPECT_EQ(stored_row2.url(), url_visited_notifications()[2].second.url());
 }
 
 TEST_F(HistoryBackendTest, AddPageArgsSource) {
   ASSERT_TRUE(backend_.get());
 
   GURL url("http://testpageargs.com");
 
   // Assume this page is browsed by user.
   HistoryAddPageArgs request1(url, base::Time::Now(), NULL, 0, GURL(),
                              history::RedirectList(),
@@ skipping 1952 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