Introduce BookmarkClient interface to abstract embedder

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.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_test_helpers.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
+#include "chrome/browser/bookmarks/test_bookmark_client.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"
@@ skipping 71 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_(NULL, false),
+      : bookmark_model_(bookmark_client_.CreateModel(false)),
         loaded_(false),
-        ui_thread_(content::BrowserThread::UI, &message_loop_) {
-  }
+        ui_thread_(content::BrowserThread::UI, &message_loop_) {}
 
   virtual ~HistoryBackendTestBase() {
     STLDeleteValues(&broadcasted_notifications_);
   }
 
  protected:
   int num_broadcasted_notifications() const {
     return broadcasted_notifications_.size();
   }
 
@@ skipping 13 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_;
   scoped_refptr<HistoryBackend> backend_;  // Will be NULL on init failure.
   scoped_ptr<InMemoryHistoryBackend> mem_backend_;
-  BookmarkModel bookmark_model_;
+  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_);
+    backend_ = new HistoryBackend(
+        test_dir_, new HistoryBackendTestDelegate(this), bookmark_model_.get());
     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();
@@ skipping 423 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());
+  bookmark_model_->AddURL(
+      bookmark_model_->bookmark_bar_node(), 0, base::string16(), 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(bookmark_model_->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_, row1.url(),
-                                     base::string16());
-  bookmark_utils::AddIfNotBookmarked(&bookmark_model_, row2.url(),
-                                     base::string16());
+  bookmark_utils::AddIfNotBookmarked(
+      bookmark_model_.get(), row1.url(), base::string16());
+  bookmark_utils::AddIfNotBookmarked(
+      bookmark_model_.get(), row2.url(), base::string16());
 
   // 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_, row2.url());
+  bookmark_utils::RemoveAllBookmarks(bookmark_model_.get(), 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_, row1.url());
+  bookmark_utils::RemoveAllBookmarks(bookmark_model_.get(), 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);
+  bookmark_model_->AddURL(
+      bookmark_model_->bookmark_bar_node(), 0, base::string16(), 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 381 matching lines @@
   // 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_);
+                                bookmark_model_.get());
   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 1382 matching lines @@
   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_);
+                                bookmark_model_.get());
   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 481 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