Refactor HistoryService to not send NOTIFICATION_FAVICON_CHANGED

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 74 matching lines @@
 // 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 NotifyFaviconChanged(const std::set<GURL>& urls) OVERRIDE;
   virtual void BroadcastNotifications(
       int type,
       scoped_ptr<HistoryDetails> details) OVERRIDE;
   virtual void DBLoaded() OVERRIDE;
   virtual void NotifyVisitDBObserversOnAddVisit(
       const BriefVisitInfo& info) 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;
 
   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_broadcasted_notifications() const {
     return broadcasted_notifications_.size();
   }
 
   const NotificationList& broadcasted_notifications() const {
     return broadcasted_notifications_;
   }
 
   void ClearBroadcastedNotifications() {
     STLDeleteValues(&broadcasted_notifications_);
   }
 
   base::FilePath test_dir() {
     return test_dir_;
   }
 
+  void NotifyFaviconChanged(const std::set<GURL>& changed_favicons) {
+    ++favicon_changed_notifications_;
+  }
+
   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
   virtual void SetUp() {
+    ClearFaviconChangedNotificationCounter();
     if (!base::CreateNewTempDirectory(FILE_PATH_LITERAL("BackendTest"),
                                       &test_dir_))
       return;
     backend_ = new HistoryBackend(
         test_dir_, new HistoryBackendTestDelegate(this), &history_client_);
     backend_->Init(std::string(), false);
   }
 
   virtual void TearDown() {
     if (backend_.get())
       backend_->Closing();
     backend_ = NULL;
     mem_backend_.reset();
     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_;
 
   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::BroadcastNotifications(
     int type,
     scoped_ptr<HistoryDetails> details) {
   test_->BroadcastNotifications(type, details.Pass());
 }
 
 void HistoryBackendTestDelegate::DBLoaded() {
   test_->loaded_ = true;
 }
 
@@ skipping 1435 matching lines @@
   EXPECT_TRUE(BitmapColorEqual(SK_ColorWHITE, bitmap_data_out));
   EXPECT_EQ(kLargeSize, pixel_size_out);
 
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   // Notifications should have been broadcast for each call to SetFavicons().
-  EXPECT_EQ(2, num_broadcasted_notifications());
+  EXPECT_EQ(2, favicon_changed_notifications());
 }
 
 // Test updating a single favicon bitmap's data via SetFavicons.
 TEST_F(HistoryBackendTest, SetFaviconsReplaceBitmapData) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon");
   std::vector<SkBitmap> bitmaps;
   bitmaps.push_back(CreateBitmap(SK_ColorBLUE, kSmallEdgeSize));
 
   // Add bitmap to the database.
   backend_->SetFavicons(page_url, favicon_base::FAVICON, icon_url, bitmaps);
 
   favicon_base::FaviconID original_favicon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
           icon_url, favicon_base::FAVICON, NULL);
   EXPECT_NE(0, original_favicon_id);
   FaviconBitmap original_favicon_bitmap;
   EXPECT_TRUE(
       GetOnlyFaviconBitmap(original_favicon_id, &original_favicon_bitmap));
   EXPECT_TRUE(
       BitmapColorEqual(SK_ColorBLUE, original_favicon_bitmap.bitmap_data));
 
-  EXPECT_EQ(1, num_broadcasted_notifications());
+  EXPECT_EQ(1, favicon_changed_notifications());
 
   // Call SetFavicons() with completely identical data.
   bitmaps[0] = CreateBitmap(SK_ColorBLUE, kSmallEdgeSize);
   backend_->SetFavicons(page_url, favicon_base::FAVICON, icon_url, bitmaps);
 
   favicon_base::FaviconID updated_favicon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
           icon_url, favicon_base::FAVICON, NULL);
   EXPECT_NE(0, updated_favicon_id);
   FaviconBitmap updated_favicon_bitmap;
   EXPECT_TRUE(
       GetOnlyFaviconBitmap(updated_favicon_id, &updated_favicon_bitmap));
   EXPECT_TRUE(
       BitmapColorEqual(SK_ColorBLUE, updated_favicon_bitmap.bitmap_data));
 
   // Because the bitmap data is byte equivalent, no notifications should have
   // been broadcasted.
-  EXPECT_EQ(1, num_broadcasted_notifications());
+  EXPECT_EQ(1, favicon_changed_notifications());
 
   // Call SetFavicons() with a different bitmap of the same size.
   bitmaps[0] = CreateBitmap(SK_ColorWHITE, kSmallEdgeSize);
   backend_->SetFavicons(page_url, favicon_base::FAVICON, icon_url, bitmaps);
 
   updated_favicon_id = backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
       icon_url, favicon_base::FAVICON, NULL);
   EXPECT_NE(0, updated_favicon_id);
   EXPECT_TRUE(
       GetOnlyFaviconBitmap(updated_favicon_id, &updated_favicon_bitmap));
   EXPECT_TRUE(
       BitmapColorEqual(SK_ColorWHITE, updated_favicon_bitmap.bitmap_data));
 
   // There should be no churn in FaviconIDs or FaviconBitmapIds even though
   // the bitmap data changed.
   EXPECT_EQ(original_favicon_bitmap.icon_id, updated_favicon_bitmap.icon_id);
   EXPECT_EQ(original_favicon_bitmap.bitmap_id,
             updated_favicon_bitmap.bitmap_id);
 
   // A notification should have been broadcasted as the favicon bitmap data has
   // changed.
-  EXPECT_EQ(2, num_broadcasted_notifications());
+  EXPECT_EQ(2, favicon_changed_notifications());
 }
 
 // Test that if two pages share the same FaviconID, changing the favicon for
 // one page does not affect the other.
 TEST_F(HistoryBackendTest, SetFaviconsSameFaviconURLForTwoPages) {
   GURL icon_url("http://www.google.com/favicon.ico");
   GURL icon_url_new("http://www.google.com/favicon2.ico");
   GURL page_url1("http://www.google.com");
   GURL page_url2("http://www.google.ca");
   std::vector<SkBitmap> bitmaps;
@@ skipping 53 matching lines @@
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   favicon_bitmaps.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmaps(favicon_id,
                                                          &favicon_bitmaps));
   EXPECT_EQ(2u, favicon_bitmaps.size());
 
   // A notification should have been broadcast for each call to SetFavicons()
   // and each call to UpdateFaviconMappingsAndFetch().
-  EXPECT_EQ(3, num_broadcasted_notifications());
+  EXPECT_EQ(3, favicon_changed_notifications());
 }
 
 // Test that no notifications are broadcast as a result of calling
 // UpdateFaviconMappingsAndFetch() for an icon URL which is already
 // mapped to the passed in page URL.
 TEST_F(HistoryBackendTest, UpdateFaviconMappingsAndFetchNoChange) {
   GURL page_url("http://www.google.com");
   GURL icon_url("http://www.google.com/favicon.ico");
   std::vector<SkBitmap> bitmaps;
   bitmaps.push_back(CreateBitmap(SK_ColorBLUE, kSmallEdgeSize));
 
   backend_->SetFavicons(page_url, favicon_base::FAVICON, icon_url, bitmaps);
 
   favicon_base::FaviconID icon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
           icon_url, favicon_base::FAVICON, NULL);
   EXPECT_NE(0, icon_id);
-  EXPECT_EQ(1, num_broadcasted_notifications());
+  EXPECT_EQ(1, favicon_changed_notifications());
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_url);
 
   std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
   backend_->UpdateFaviconMappingsAndFetch(page_url,
                                           icon_urls,
                                           favicon_base::FAVICON,
                                           GetEdgeSizesSmallAndLarge(),
                                           &bitmap_results);
 
   EXPECT_EQ(icon_id,
             backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
                 icon_url, favicon_base::FAVICON, NULL));
 
   // No notification should have been broadcast as no icon mapping, favicon,
   // or favicon bitmap was updated, added or removed.
-  EXPECT_EQ(1, num_broadcasted_notifications());
+  EXPECT_EQ(1, favicon_changed_notifications());
 }
 
 // Test repeatedly calling MergeFavicon(). |page_url| is initially not known
 // to the database.
 TEST_F(HistoryBackendTest, MergeFaviconPageURLNotInDB) {
   GURL page_url("http://www.google.com");
   GURL icon_url("http:/www.google.com/favicon.ico");
 
   std::vector<unsigned char> data;
   data.push_back('a');
@@ skipping 52 matching lines @@
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url1, icon_mappings[0].icon_url);
 
   FaviconBitmap favicon_bitmap;
   EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
   EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapColorEqual(SK_ColorBLUE, favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
-  EXPECT_EQ(1, num_broadcasted_notifications());
+  EXPECT_EQ(1, favicon_changed_notifications());
 
   // 1) Merge identical favicon bitmap.
   std::vector<unsigned char> data;
   gfx::PNGCodec::EncodeBGRASkBitmap(bitmaps[0], false, &data);
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       new base::RefCountedBytes(data));
   backend_->MergeFavicon(
       page_url, icon_url1, favicon_base::FAVICON, bitmap_data, kSmallSize);
 
   // All the data should stay the same and no notifications should have been
   // sent.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url1, icon_mappings[0].icon_url);
 
   EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
   EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapColorEqual(SK_ColorBLUE, favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
-  EXPECT_EQ(1, num_broadcasted_notifications());
+  EXPECT_EQ(1, favicon_changed_notifications());
 
   // 2) Merge favicon bitmap of the same size.
   data.clear();
   data.push_back('b');
   bitmap_data = new base::RefCountedBytes(data);
   backend_->MergeFavicon(
       page_url, icon_url1, favicon_base::FAVICON, bitmap_data, kSmallSize);
 
   // The small favicon bitmap at |icon_url1| should be overwritten.
   icon_mappings.clear();
@@ skipping 54 matching lines @@
   EXPECT_TRUE(BitmapDataEqual('c', favicon_bitmaps[0].bitmap_data));
   EXPECT_EQ(kTinySize, favicon_bitmaps[0].pixel_size);
   // The favicon being merged should take precedence over the preexisting
   // favicon bitmaps.
   EXPECT_NE(base::Time(), favicon_bitmaps[1].last_updated);
   EXPECT_TRUE(BitmapDataEqual('d', favicon_bitmaps[1].bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmaps[1].pixel_size);
 
   // A notification should have been broadcast for each call to SetFavicons()
   // and MergeFavicon().
-  EXPECT_EQ(4, num_broadcasted_notifications());
+  EXPECT_EQ(4, favicon_changed_notifications());
 }
 
 // Test calling MergeFavicon() when |icon_url| is known to the database but not
 // mapped to |page_url|.
 TEST_F(HistoryBackendTest, MergeFaviconIconURLMappedToDifferentPageURL) {
   GURL page_url1("http://www.google.com");
   GURL page_url2("http://news.google.com");
   GURL page_url3("http://maps.google.com");
   GURL icon_url("http:/www.google.com/favicon.ico");
   std::vector<SkBitmap> bitmaps;
@@ skipping 64 matching lines @@
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url3,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   // A notification should have been broadcast for each call to SetFavicons()
   // and MergeFavicon().
-  EXPECT_EQ(3, num_broadcasted_notifications());
+  EXPECT_EQ(3, favicon_changed_notifications());
 }
 
 // Test that MergeFavicon() does not add more than
 // |kMaxFaviconBitmapsPerIconURL| to a favicon.
 TEST_F(HistoryBackendTest, MergeFaviconMaxFaviconBitmapsPerIconURL) {
   GURL page_url("http://www.google.com");
   std::string icon_url_string("http://www.google.com/favicon.ico");
   size_t replace_index = icon_url_string.size() - 1;
 
   std::vector<unsigned char> data;
@@ skipping 1103 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