bookmarks: Get rid of the dependency on history_notifications.h

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 <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
+#include "chrome/browser/favicon/favicon_changed_details.h"
 #include "chrome/browser/favicon/imported_favicon_usage.h"
 #include "chrome/browser/history/history_backend.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_database.h"
 #include "chrome/browser/history/in_memory_history_backend.h"
 #include "chrome/browser/history/visit_filter.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/thumbnail_score.h"
+#include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/ui_test_utils.h"
 #include "chrome/tools/profiles/thumbnail-inl.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
+#include "content/public/test/test_browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/image/image.h"
 
 using base::Time;
 using base::TimeDelta;
 
 // This file only tests functionality where it is most convenient to call the
@@ skipping 32 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(HistoryBackendTest* test) : test_(test) {}
 
   virtual void NotifyProfileError(int backend_id,
                                   sql::InitStatus init_status) OVERRIDE {}
   virtual void SetInMemoryBackend(int backend_id,
                                   InMemoryHistoryBackend* backend) OVERRIDE;
+  virtual void SendFaviconChangedNotification(
+      chrome::FaviconChangedDetails* details) OVERRIDE;
   virtual void BroadcastNotifications(int type,
                                       HistoryDetails* details) OVERRIDE;
   virtual void DBLoaded(int backend_id) OVERRIDE;
   virtual void StartTopSitesMigration(int backend_id) OVERRIDE;
   virtual void NotifyVisitDBObserversOnAddVisit(
       const BriefVisitInfo& info) OVERRIDE {}
 
  private:
   // Not owned by us.
   HistoryBackendTest* test_;
@@ skipping 13 matching lines @@
     AddRequest(request, this);
     return request->handle();
   }
 };
 
 class HistoryBackendTest : public testing::Test {
  public:
   HistoryBackendTest()
       : bookmark_model_(NULL),
         loaded_(false),
-        num_broadcasted_notifications_(0) {
+        num_favicon_notifications_(0),
+        num_broadcasted_notifications_(0),
+        ui_thread_(content::BrowserThread::UI, &message_loop_) {
   }
 
   virtual ~HistoryBackendTest() {
   }
 
   // Callback for QueryMostVisited.
   void OnQueryMostVisited(CancelableRequestProvider::Handle handle,
                           history::MostVisitedURLList data) {
     most_visited_list_.swap(data);
   }
 
   // Callback for QueryFiltered.
   void OnQueryFiltered(CancelableRequestProvider::Handle handle,
                        const history::FilteredURLList& data) {
     filtered_list_ = data;
   }
 
   const history::MostVisitedURLList& get_most_visited_list() const {
     return most_visited_list_;
   }
 
   const history::FilteredURLList& get_filtered_list() const {
     return filtered_list_;
   }
 
+  int num_favicon_notifications() const { return num_favicon_notifications_; }
+
   int num_broadcasted_notifications() const {
     return num_broadcasted_notifications_;
   }
 
  protected:
   scoped_refptr<HistoryBackend> backend_;  // Will be NULL on init failure.
   scoped_ptr<InMemoryHistoryBackend> mem_backend_;
 
   void AddRedirectChain(const char* sequence[], int page_id) {
     AddRedirectChainWithTransitionAndTime(sequence, page_id,
@@ skipping 227 matching lines @@
       backend_->Closing();
     backend_ = NULL;
     mem_backend_.reset();
     file_util::Delete(test_dir_, true);
   }
 
   void SetInMemoryBackend(int backend_id, InMemoryHistoryBackend* backend) {
     mem_backend_.reset(backend);
   }
 
+  void SendFaviconChangedNotification(chrome::FaviconChangedDetails* details) {
+    ++num_favicon_notifications_;
+    // The backend passes ownership of the details pointer to us.
+    delete details;
+  }
+
   void BroadcastNotifications(int type,
                               HistoryDetails* details) {
     ++num_broadcasted_notifications_;
 
     // Send the notifications directly to the in-memory database.
     content::Details<HistoryDetails> det(details);
     mem_backend_->Observe(type, content::Source<HistoryBackendTest>(NULL), det);
 
     // The backend passes ownership of the details pointer to us.
     delete details;
   }
 
+  // The number of chrome::NOTIFICATION_FAVICON_CHANGED notifications that were
+  // dispatched.
+  int num_favicon_notifications_;
+
   // The number of notifications which were broadcasted.
   int num_broadcasted_notifications_;
 
   MessageLoop message_loop_;
+  content::TestBrowserThread ui_thread_;
   base::FilePath test_dir_;
   history::MostVisitedURLList most_visited_list_;
   history::FilteredURLList filtered_list_;
 };
 
 void HistoryBackendTestDelegate::SetInMemoryBackend(int backend_id,
     InMemoryHistoryBackend* backend) {
   test_->SetInMemoryBackend(backend_id, backend);
 }
 
+void HistoryBackendTestDelegate::SendFaviconChangedNotification(
+    chrome::FaviconChangedDetails* details) {
+  test_->SendFaviconChangedNotification(details);
+}
+
 void HistoryBackendTestDelegate::BroadcastNotifications(
     int type,
     HistoryDetails* details) {
   test_->BroadcastNotifications(type, details);
 }
 
 void HistoryBackendTestDelegate::DBLoaded(int backend_id) {
   test_->loaded_ = true;
 }
 
@@ skipping 1039 matching lines @@
   favicon_bitmap_data.clear();
   backend_->SetFavicons(page_url, chrome::FAVICON, favicon_bitmap_data);
 
   EXPECT_FALSE(backend_->thumbnail_db_->GetFaviconBitmap(large_bitmap_id, NULL,
       NULL, NULL));
   icon_mappings.clear();
   EXPECT_FALSE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
 
   // Notifications should have been broadcast for each call to SetFavicons().
-  EXPECT_EQ(3, num_broadcasted_notifications());
+  EXPECT_EQ(3, num_favicon_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<unsigned char> data_initial;
   data_initial.push_back('a');
 
@@ skipping 10 matching lines @@
 
   chrome::FaviconID original_favicon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
           icon_url, chrome::FAVICON, NULL);
   EXPECT_NE(0, original_favicon_id);
   FaviconBitmap original_favicon_bitmap;
   EXPECT_TRUE(
       GetOnlyFaviconBitmap(original_favicon_id, &original_favicon_bitmap));
   EXPECT_TRUE(BitmapDataEqual('a', original_favicon_bitmap.bitmap_data));
 
-  EXPECT_EQ(1, num_broadcasted_notifications());
+  EXPECT_EQ(1, num_favicon_notifications());
 
   // Call SetFavicons() with completely identical data.
   std::vector<unsigned char> updated_data;
   updated_data.push_back('a');
   favicon_bitmap_data[0].bitmap_data = new base::RefCountedBytes(updated_data);
   backend_->SetFavicons(page_url, chrome::FAVICON, favicon_bitmap_data);
 
   chrome::FaviconID updated_favicon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
           icon_url, chrome::FAVICON, NULL);
   EXPECT_NE(0, updated_favicon_id);
   FaviconBitmap updated_favicon_bitmap;
   EXPECT_TRUE(
       GetOnlyFaviconBitmap(updated_favicon_id, &updated_favicon_bitmap));
   EXPECT_TRUE(BitmapDataEqual('a', 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, num_favicon_notifications());
 
   // Call SetFavicons() with identical data but a different bitmap.
   updated_data[0] = 'b';
   favicon_bitmap_data[0].bitmap_data = new base::RefCountedBytes(updated_data);
   backend_->SetFavicons(page_url, chrome::FAVICON, favicon_bitmap_data);
 
   updated_favicon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
           icon_url, chrome::FAVICON, NULL);
   EXPECT_NE(0, updated_favicon_id);
   EXPECT_TRUE(
       GetOnlyFaviconBitmap(updated_favicon_id, &updated_favicon_bitmap));
   EXPECT_TRUE(BitmapDataEqual('b', 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, num_favicon_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");
 
@@ skipping 51 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, num_favicon_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<chrome::FaviconBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url, GetSizesSmall(), &favicon_bitmap_data);
 
   backend_->SetFavicons(page_url, chrome::FAVICON, favicon_bitmap_data);
 
   chrome::FaviconID icon_id =
     backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
         icon_url, chrome::FAVICON, NULL);
   EXPECT_NE(0, icon_id);
-  EXPECT_EQ(1, num_broadcasted_notifications());
+  EXPECT_EQ(1, num_favicon_notifications());
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_url);
 
   std::vector<chrome::FaviconBitmapResult> bitmap_results;
   backend_->UpdateFaviconMappingsAndFetch(
       page_url, icon_urls, chrome::FAVICON, kSmallSize.width(),
       GetScaleFactors1x2x(), &bitmap_results);
 
   EXPECT_EQ(icon_id, backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
       icon_url, chrome::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, num_favicon_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 54 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(BitmapDataEqual('a', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
-  EXPECT_EQ(1, num_broadcasted_notifications());
+  EXPECT_EQ(1, num_favicon_notifications());
 
   // 1) Merge identical favicon bitmap.
   std::vector<unsigned char> data;
   data.push_back('a');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       new base::RefCountedBytes(data));
   backend_->MergeFavicon(
       page_url, icon_url1, chrome::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(BitmapDataEqual('a', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
-  EXPECT_EQ(1, num_broadcasted_notifications());
+  EXPECT_EQ(1, num_favicon_notifications());
 
   // 2) Merge favicon bitmap of the same size.
   data[0] = 'b';
   bitmap_data = new base::RefCountedBytes(data);
   backend_->MergeFavicon(
       page_url, icon_url1, chrome::FAVICON, bitmap_data, kSmallSize);
 
   // The small favicon bitmap at |icon_url1| should be overwritten.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
@@ skipping 53 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, num_favicon_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");
 
@@ 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, num_favicon_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 849 matching lines @@
   ASSERT_EQ(2u, data.size());
   EXPECT_EQ(url2.spec(), data[0]->GetURL().spec());
   EXPECT_EQ(url2_id, data[0]->GetID());
   EXPECT_EQ(segment2_time_delta.InHours(), data[0]->duration().InHours());
 
   EXPECT_EQ(url1.spec(), data[1]->GetURL().spec());
   EXPECT_EQ(url1_id, data[1]->GetID());
   EXPECT_EQ(segment1_time_delta.InHours(), data[1]->duration().InHours());
 }
 
+// Simple test that removes a bookmark. This test exercises the code paths in
+// History that block till bookmark bar model is loaded.
+TEST_F(HistoryBackendTest, RemoveNotification) {
+  scoped_ptr<TestingProfile> profile(new TestingProfile());
+  profile->CreateHistoryService(false, false);
+  profile->CreateBookmarkModel(true);
+
+  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile.get());
+  ui_test_utils::WaitForBookmarkModelToLoad(model);
+
+  // Add a URL.
+  GURL url("http://www.google.com");
+  bookmark_utils::AddIfNotBookmarked(model, url, string16());
+
+  HistoryService* service = HistoryServiceFactory::GetForProfile(
+      profile.get(), Profile::EXPLICIT_ACCESS);
+  service->AddPage(url,
+                   base::Time::Now(),
+                   NULL,
+                   1,
+                   GURL(),
+                   RedirectList(),
+                   content::PAGE_TRANSITION_TYPED,
+                   SOURCE_BROWSED,
+                   false);
+
+  // This won't actually delete the URL, rather it'll empty out the visits.
+  // This triggers blocking on the BookmarkModel.
+  service->DeleteURL(url);
+}
+
 }  // namespace history