Abstract history dependencies on bookmarks through HistoryClient

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/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/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/chrome_notification_types.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/importer/imported_favicon_usage.h"
 #include "chrome/test/base/testing_profile.h"
-#include "components/bookmarks/browser/bookmark_model.h"
-#include "components/bookmarks/browser/bookmark_utils.h"
-#include "components/bookmarks/test/bookmark_test_helpers.h"
-#include "components/bookmarks/test/test_bookmark_client.h"
+#include "components/history/core/test/history_client_fake_bookmarks.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/test/test_browser_thread.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using base::Time;
 
 // This file only tests functionality where it is most convenient to call the
 // backend directly. Most of the history backend functions are tested by the
 // history unit test. Because of the elaborate callbacks involved, this is no
 // harder than calling it directly for many things.
 
 namespace {
 
 static const gfx::Size kTinySize = gfx::Size(10, 10);
 static const gfx::Size kSmallSize = gfx::Size(16, 16);
 static const gfx::Size kLargeSize = gfx::Size(32, 32);
 
 // 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());
+};
+
 }  // 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:
@@ skipping 29 matching lines @@
     AddRequest(request, this);
     return request->handle();
   }
 };
 
 class HistoryBackendTestBase : public testing::Test {
  public:
   typedef std::vector<std::pair<int, HistoryDetails*> > NotificationList;
 
   HistoryBackendTestBase()
-      : bookmark_model_(bookmark_client_.CreateModel(false)),
-        loaded_(false),
+      : loaded_(false),
         ui_thread_(content::BrowserThread::UI, &message_loop_) {}
 
   virtual ~HistoryBackendTestBase() {
     STLDeleteValues(&broadcasted_notifications_);
   }
 
  protected:
   int num_broadcasted_notifications() const {
     return broadcasted_notifications_.size();
   }
@@ skipping 14 matching lines @@
     // 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()));
   }
 
-  test::TestBookmarkClient bookmark_client_;
+  history::HistoryClientFakeBookmarks history_client_;
   scoped_refptr<HistoryBackend> backend_;  // Will be NULL on init failure.
   scoped_ptr<InMemoryHistoryBackend> mem_backend_;
-  scoped_ptr<BookmarkModel> bookmark_model_;
   bool loaded_;
 
  private:
   friend class HistoryBackendTestDelegate;
 
   // testing::Test
   virtual void SetUp() {
     if (!base::CreateNewTempDirectory(FILE_PATH_LITERAL("BackendTest"),
                                       &test_dir_))
       return;
     backend_ = new HistoryBackend(
-        test_dir_, new HistoryBackendTestDelegate(this), bookmark_model_.get());
+        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_;
 
   base::MessageLoop message_loop_;
@@ skipping 413 matching lines @@
   backend_->db_->GetVisitsForURL(row2_id, &visits);
   ASSERT_EQ(1U, visits.size());
 
   // The in-memory backend should have been set and it should have gotten the
   // typed URL.
   ASSERT_TRUE(mem_backend_.get());
   URLRow outrow1;
   EXPECT_TRUE(mem_backend_->db_->GetRowForURL(row1.url(), NULL));
 
   // Star row1.
-  bookmark_model_->AddURL(
-      bookmark_model_->bookmark_bar_node(), 0, base::string16(), row1.url());
+  history_client_.AddBookmark(row1.url());
 
   // Now finally clear all history.
   ClearBroadcastedNotifications();
   backend_->DeleteAllHistory();
 
   // The first URL should be preserved but the time should be cleared.
   EXPECT_TRUE(backend_->db_->GetRowForURL(row1.url(), &outrow1));
   EXPECT_EQ(row1.url(), outrow1.url());
   EXPECT_EQ(0, outrow1.visit_count());
   EXPECT_EQ(0, outrow1.typed_count());
@@ skipping 43 matching lines @@
 
   // The remaining URL should still reference the same favicon, even if its
   // ID has changed.
   std::vector<IconMapping> mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       outrow1.url(), favicon_base::FAVICON, &mappings));
   EXPECT_EQ(1u, mappings.size());
   EXPECT_EQ(out_favicon1, mappings[0].icon_id);
 
   // The first URL should still be bookmarked.
-  EXPECT_TRUE(bookmark_model_->IsBookmarked(row1.url()));
+  EXPECT_TRUE(history_client_.IsBookmarked(row1.url()));
 
   // Check that we fire the notification about all history having been deleted.
   ASSERT_EQ(1u, broadcasted_notifications().size());
   ASSERT_EQ(chrome::NOTIFICATION_HISTORY_URLS_DELETED,
             broadcasted_notifications()[0].first);
   const URLsDeletedDetails* details = static_cast<const URLsDeletedDetails*>(
       broadcasted_notifications()[0].second);
   EXPECT_TRUE(details->all_history);
   EXPECT_FALSE(details->archived);
 }
@@ skipping 77 matching lines @@
 
   URLRows rows;
   rows.push_back(row2);  // Reversed order for the same reason as favicons.
   rows.push_back(row1);
   backend_->AddPagesWithDetails(rows, history::SOURCE_BROWSED);
 
   URLID row1_id = backend_->db_->GetRowForURL(row1.url(), NULL);
   URLID row2_id = backend_->db_->GetRowForURL(row2.url(), NULL);
 
   // Star the two URLs.
-  bookmark_utils::AddIfNotBookmarked(
-      bookmark_model_.get(), row1.url(), base::string16());
-  bookmark_utils::AddIfNotBookmarked(
-      bookmark_model_.get(), row2.url(), base::string16());
+  history_client_.AddBookmark(row1.url());
+  history_client_.AddBookmark(row2.url());
 
   // Delete url 2. Because url 2 is starred this won't delete the URL, only
   // the visits.
   backend_->expirer_.DeleteURL(row2.url());
 
   // Make sure url 2 is still valid, but has no visits.
   URLRow tmp_url_row;
   EXPECT_EQ(row2_id, backend_->db_->GetRowForURL(row2.url(), NULL));
   VisitVector visits;
   backend_->db_->GetVisitsForURL(row2_id, &visits);
   EXPECT_EQ(0U, visits.size());
   // The favicon should still be valid.
   EXPECT_EQ(favicon2,
             backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
                 favicon_url2, favicon_base::FAVICON, NULL));
 
   // Unstar row2.
-  bookmark_utils::RemoveAllBookmarks(bookmark_model_.get(), row2.url());
+  history_client_.DelBookmark(row2.url());
 
   // Tell the backend it was unstarred. We have to explicitly do this as
   // BookmarkModel isn't wired up to the backend during testing.
   std::set<GURL> unstarred_urls;
   unstarred_urls.insert(row2.url());
   backend_->URLsNoLongerBookmarked(unstarred_urls);
 
   // The URL should no longer exist.
   EXPECT_FALSE(backend_->db_->GetRowForURL(row2.url(), &tmp_url_row));
   // And the favicon should be deleted.
   EXPECT_EQ(0,
             backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
                 favicon_url2, favicon_base::FAVICON, NULL));
 
   // Unstar row 1.
-  bookmark_utils::RemoveAllBookmarks(bookmark_model_.get(), row1.url());
+  history_client_.DelBookmark(row1.url());
+
   // Tell the backend it was unstarred. We have to explicitly do this as
   // BookmarkModel isn't wired up to the backend during testing.
   unstarred_urls.clear();
   unstarred_urls.insert(row1.url());
   backend_->URLsNoLongerBookmarked(unstarred_urls);
 
   // The URL should still exist (because there were visits).
   EXPECT_EQ(row1_id, backend_->db_->GetRowForURL(row1.url(), NULL));
 
   // There should still be visits.
@@ skipping 251 matching lines @@
   favicons.clear();
   favicon.favicon_url = GURL("http://mail.google.com/favicon.ico");
   favicon.png_data.push_back('3');
   favicon.urls.insert(url3);
   favicons.push_back(favicon);
   backend_->SetImportedFavicons(favicons);
   URLRow url_row3;
   EXPECT_TRUE(backend_->db_->GetRowForURL(url3, &url_row3) == 0);
 
   // If the URL is bookmarked, it should get added to history with 0 visits.
-  bookmark_model_->AddURL(
-      bookmark_model_->bookmark_bar_node(), 0, base::string16(), url3);
+  history_client_.AddBookmark(url3);
   backend_->SetImportedFavicons(favicons);
   EXPECT_FALSE(backend_->db_->GetRowForURL(url3, &url_row3) == 0);
   EXPECT_TRUE(url_row3.visit_count() == 0);
 }
 
 TEST_F(HistoryBackendTest, StripUsernamePasswordTest) {
   ASSERT_TRUE(backend_.get());
 
   GURL url("http://anyuser:anypass@www.google.com");
   GURL stripped_url("http://www.google.com");
@@ skipping 379 matching lines @@
 
   // Copy history database file to current directory so that it will be deleted
   // in Teardown.
   base::FilePath new_history_path(test_dir());
   base::DeleteFile(new_history_path, true);
   base::CreateDirectory(new_history_path);
   base::FilePath new_history_file =
       new_history_path.Append(chrome::kHistoryFilename);
   ASSERT_TRUE(base::CopyFile(old_history_path, new_history_file));
 
-  backend_ = new HistoryBackend(new_history_path,
-                                new HistoryBackendTestDelegate(this),
-                                bookmark_model_.get());
+  backend_ = new HistoryBackend(
+      new_history_path, new HistoryBackendTestDelegate(this), &history_client_);
   backend_->Init(std::string(), false);
   backend_->Closing();
   backend_ = NULL;
 
   // Now the database should already be migrated.
   // Check version first.
   int cur_version = HistoryDatabase::GetCurrentVersion();
   sql::Connection db;
   ASSERT_TRUE(db.Open(new_history_file));
   sql::Statement s(db.GetUniqueStatement(
@@ skipping 1380 matching lines @@
   base::FilePath new_history_path(test_dir());
   base::DeleteFile(new_history_path, true);
   base::CreateDirectory(new_history_path);
   base::FilePath new_history_file =
       new_history_path.Append(chrome::kHistoryFilename);
   base::FilePath new_archived_file =
       new_history_path.Append(chrome::kArchivedHistoryFilename);
   ASSERT_TRUE(base::CopyFile(old_history, new_history_file));
   ASSERT_TRUE(base::CopyFile(old_archived, new_archived_file));
 
-  backend_ = new HistoryBackend(new_history_path,
-                                new HistoryBackendTestDelegate(this),
-                                bookmark_model_.get());
+  backend_ = new HistoryBackend(
+      new_history_path, new HistoryBackendTestDelegate(this), &history_client_);
   backend_->Init(std::string(), false);
   backend_->Closing();
   backend_ = NULL;
 
   // Now both history and archived_history databases should already be migrated.
 
   // Check version in history database first.
   int cur_version = HistoryDatabase::GetCurrentVersion();
   sql::Connection db;
   ASSERT_TRUE(db.Open(new_history_file));
@@ skipping 215 matching lines @@
   EXPECT_TRUE(backend_->db()->GetKeywordSearchTermRow(url1_id, NULL));
   EXPECT_FALSE(backend_->db()->GetKeywordSearchTermRow(url2_id, NULL));
   EXPECT_FALSE(backend_->db()->GetKeywordSearchTermRow(url3_id, NULL));
 }
 
 // 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());
 
-  ASSERT_TRUE(profile->CreateHistoryService(false, false));
-  profile->CreateBookmarkModel(true);
-  BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile.get());
-  test::WaitForBookmarkModelToLoad(model);
-
   // Add a URL.
   GURL url("http://www.google.com");
-  bookmark_utils::AddIfNotBookmarked(model, url, base::string16());
-
-  HistoryService* service = HistoryServiceFactory::GetForProfile(
-      profile.get(), Profile::EXPLICIT_ACCESS);
+  HistoryClientMock history_client;
+  history_client.AddBookmark(url);
+  scoped_ptr<HistoryService> service(
+      new HistoryService(&history_client, profile.get()));
+  EXPECT_TRUE(service->Init(profile->GetPath()));
 
   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.
+  EXPECT_CALL(history_client, BlockUntilBookmarksLoaded());
   service->DeleteURL(url);
 }
 
 // Test DeleteFTSIndexDatabases deletes expected files.
 TEST_F(HistoryBackendTest, DeleteFTSIndexDatabases) {
   ASSERT_TRUE(backend_.get());
 
   base::FilePath history_path(test_dir());
   base::FilePath db1(history_path.AppendASCII("History Index 2013-05"));
   base::FilePath db1_journal(db1.InsertBeforeExtensionASCII("-journal"));
@@ skipping 228 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