Remove //chrome and //content deps from ProfileSyncServiceBookmarkTest

chrome/browser/sync/profile_sync_service_bookmark_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.
 
 // TODO(akalin): This file is basically just a unit test for
 // BookmarkChangeProcessor.  Write unit tests for
 // BookmarkModelAssociator separately.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <queue>
 #include <stack>
+#include <utility>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
-#include "chrome/browser/bookmarks/bookmark_model_factory.h"
-#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
-#include "chrome/browser/favicon/favicon_service_factory.h"
-#include "chrome/browser/history/history_service_factory.h"
-#include "chrome/test/base/testing_profile.h"
 #include "components/bookmarks/browser/base_bookmark_model_observer.h"
 #include "components/bookmarks/browser/bookmark_model.h"
+#include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/managed/managed_bookmark_service.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
+#include "components/bookmarks/test/test_bookmark_client.h"
+#include "components/browser_sync/browser/profile_sync_test_util.h"
 #include "components/sync_bookmarks/bookmark_change_processor.h"
 #include "components/sync_bookmarks/bookmark_model_associator.h"
 #include "components/sync_driver/data_type_error_handler.h"
 #include "components/sync_driver/data_type_error_handler_mock.h"
 #include "components/sync_driver/fake_sync_client.h"
-#include "content/public/test/test_browser_thread_bundle.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/internal_api/public/change_record.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/test/test_user_share.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/internal_api/syncapi_internal.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_id.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace browser_sync {
-
 using bookmarks::BookmarkModel;
 using bookmarks::BookmarkNode;
 using syncer::BaseNode;
 using testing::_;
 using testing::Return;
 using testing::StrictMock;
 
+namespace browser_sync {
+
+namespace {
+
 #if defined(OS_ANDROID) || defined(OS_IOS)
 static const bool kExpectMobileBookmarks = true;
 #else
 static const bool kExpectMobileBookmarks = false;
 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
 
-namespace {
+std::string ReturnEmptyString() {
+  return std::string();
+}
 
 void MakeServerUpdate(syncer::WriteTransaction* trans,
                       syncer::WriteNode* node) {
   syncer::syncable::ChangeEntryIDAndUpdateChildren(
       trans->GetWrappedWriteTrans(), node->GetMutableEntryForTest(),
       syncer::syncable::Id::CreateFromServerId(
           base::Int64ToString(node->GetId())));
   node->GetMutableEntryForTest()->PutBaseVersion(10);
   node->GetMutableEntryForTest()->PutIsUnappliedUpdate(true);
 }
 
 void MakeServerUpdate(syncer::WriteTransaction* trans, int64_t id) {
   syncer::WriteNode node(trans);
   EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
   MakeServerUpdate(trans, &node);
 }
 
-class TestSyncClient : public sync_driver::FakeSyncClient {
- public:
-  explicit TestSyncClient(Profile* profile) : profile_(profile) {}
-
-  BookmarkModel* GetBookmarkModel() override {
-    return BookmarkModelFactory::GetForProfile(profile_);
-  }
-
-  favicon::FaviconService* GetFaviconService() override {
-    return FaviconServiceFactory::GetForProfile(
-        profile_, ServiceAccessType::EXPLICIT_ACCESS);
-  }
-
-  history::HistoryService* GetHistoryService() override {
-    return HistoryServiceFactory::GetForProfile(
-        profile_, ServiceAccessType::EXPLICIT_ACCESS);
-  }
-
- private:
-  Profile* profile_;
-};
-
 // FakeServerChange constructs a list of syncer::ChangeRecords while modifying
 // the sync model, and can pass the ChangeRecord list to a
 // syncer::SyncObserver (i.e., the ProfileSyncService) to test the client
 // change-application behavior.
 // Tests using FakeServerChange should be careful to avoid back-references,
 // since FakeServerChange will send the edits in the order specified.
 class FakeServerChange {
  public:
   explicit FakeServerChange(syncer::WriteTransaction* trans) : trans_(trans) {
   }
@@ skipping 238 matching lines @@
   }
 
  private:
   int started_count_;
   int completed_count_at_started_;
   int completed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensiveChangesBookmarkModelObserver);
 };
 
-
 class ProfileSyncServiceBookmarkTest : public testing::Test {
  protected:
   enum LoadOption { LOAD_FROM_STORAGE, DELETE_EXISTING_STORAGE };
   enum SaveOption { SAVE_TO_STORAGE, DONT_SAVE_TO_STORAGE };
 
   ProfileSyncServiceBookmarkTest()
-      : sync_client_(&profile_),
-        model_(NULL),
+      : managed_bookmark_service_(new bookmarks::ManagedBookmarkService(
+            profile_sync_service_bundle_.pref_service(),
+            base::Bind(ReturnEmptyString))),
         local_merge_result_(syncer::BOOKMARKS),
-        syncer_merge_result_(syncer::BOOKMARKS) {}
+        syncer_merge_result_(syncer::BOOKMARKS) {
+    CHECK(data_dir_.CreateUniqueTempDir());
+    browser_sync::ProfileSyncServiceBundle::SyncClientBuilder builder(
+        &profile_sync_service_bundle_);
+    builder.SetBookmarkModelCallback(base::Bind(
+        &ProfileSyncServiceBookmarkTest::model, base::Unretained(this)));
+    sync_client_ = builder.Build();
+    bookmarks::RegisterProfilePrefs(
+        profile_sync_service_bundle_.pref_service()->registry());
+  }
 
   ~ProfileSyncServiceBookmarkTest() override {
+    static_cast<KeyedService*>(managed_bookmark_service_.get())->Shutdown();
     StopSync();
-    UnloadBookmarkModel();
   }
 
   void SetUp() override { test_user_share_.SetUp(); }
 
   void TearDown() override { test_user_share_.TearDown(); }
 
   bool CanSyncNode(const BookmarkNode* node) {
     return model_->client()->CanSyncNode(node);
   }
 
@@ skipping 45 matching lines @@
 
     syncer::WriteNode node(trans);
     EXPECT_TRUE(node.InitBookmarkByCreation(parent, NULL));
     node.SetIsFolder(false);
     node.SetTitle(title);
     node.SetBookmarkSpecifics(specifics);
 
     return node.GetId();
   }
 
+  // Create a BookmarkModel. If |delete_bookmarks| is true, the bookmarks file
+  // will be deleted before starting up the BookmarkModel.
+  scoped_ptr<BookmarkModel> CreateBookmarkModel(bool delete_bookmarks) {
+    const base::FilePath& data_path = data_dir_.path();
+    auto model = make_scoped_ptr<BookmarkModel>(new BookmarkModel(
+        make_scoped_ptr(new bookmarks::TestBookmarkClient())));
+    managed_bookmark_service_->BookmarkModelCreated(model.get());
+    int64_t next_id = 0;
+    static_cast<bookmarks::TestBookmarkClient*>(model->client())
+        ->SetExtraNodesToLoad(
+            managed_bookmark_service_->GetLoadExtraNodesCallback().Run(
+                &next_id));
+    if (delete_bookmarks) {
+      base::DeleteFile(data_path.Append(FILE_PATH_LITERAL("dummy_bookmarks")),
+                       false);
+    }
+
+    model->Load(profile_sync_service_bundle_.pref_service(), std::string(),
+                data_path, base::ThreadTaskRunnerHandle::Get(),
+                base::ThreadTaskRunnerHandle::Get());
+    bookmarks::test::WaitForBookmarkModelToLoad(model.get());
+    return model;
+  }
+
   // Load (or re-load) the bookmark model.  |load| controls use of the
   // bookmarks file on disk.  |save| controls whether the newly loaded
   // bookmark model will write out a bookmark file as it goes.
   void LoadBookmarkModel(LoadOption load, SaveOption save) {
     bool delete_bookmarks = load == DELETE_EXISTING_STORAGE;
-    profile_.CreateBookmarkModel(delete_bookmarks);
-    model_ = BookmarkModelFactory::GetForProfile(&profile_);
-    bookmarks::test::WaitForBookmarkModelToLoad(model_);
+    model_.reset();
+    model_ = CreateBookmarkModel(delete_bookmarks);
     // This noticeably speeds up the unit tests that request it.
     if (save == DONT_SAVE_TO_STORAGE)
       model_->ClearStore();
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   int GetSyncBookmarkCount() {
     syncer::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     syncer::ReadNode node(&trans);
     if (node.InitTypeRoot(syncer::BOOKMARKS) != BaseNode::INIT_OK)
@@ skipping 17 matching lines @@
     }
 
     if (!root_exists) {
       if (!syncer::TestUserShare::CreateRoot(type,
                                              test_user_share_.user_share()))
         return false;
     }
 
     const int kNumPermanentNodes = 3;
     const std::string permanent_tags[kNumPermanentNodes] = {
-#if defined(OS_IOS) || defined(OS_ANDROID)
-      "synced_bookmarks",
-#endif  // defined(OS_IOS) || defined(OS_ANDROID)
-      "bookmark_bar",
-      "other_bookmarks",
-#if !defined(OS_IOS) && !defined(OS_ANDROID)
-      "synced_bookmarks",
-#endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
+        "bookmark_bar", "other_bookmarks", "synced_bookmarks",
     };
     syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     syncer::ReadNode root(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, root.InitTypeRoot(type));
 
     // Loop through creating permanent nodes as necessary.
     int64_t last_child_id = syncer::kInvalidId;
     for (int i = 0; i < kNumPermanentNodes; ++i) {
       // First check if the node already exists. This is for tests that involve
       // persistence and set up sync more than once.
@@ skipping 23 matching lines @@
       last_child_id = node.GetId();
     }
     return true;
   }
 
   bool AssociateModels() {
     DCHECK(!model_associator_);
 
     // Set up model associator.
     model_associator_.reset(new BookmarkModelAssociator(
-        BookmarkModelFactory::GetForProfile(&profile_), &sync_client_,
-        test_user_share_.user_share(), &mock_error_handler_,
-        kExpectMobileBookmarks));
+        model_.get(), sync_client_.get(), test_user_share_.user_share(),
+        &mock_error_handler_, kExpectMobileBookmarks));
 
     local_merge_result_ = syncer::SyncMergeResult(syncer::BOOKMARKS);
     syncer_merge_result_ = syncer::SyncMergeResult(syncer::BOOKMARKS);
     int local_count_before = model_->root_node()->GetTotalNodeCount();
     int syncer_count_before = GetSyncBookmarkCount();
 
     syncer::SyncError error = model_associator_->AssociateModels(
         &local_merge_result_,
         &syncer_merge_result_);
     if (error.IsSet())
@@ skipping 40 matching lines @@
     }
     model_associator_.reset();
 
     base::RunLoop().RunUntilIdle();
 
     // TODO(akalin): Actually close the database and flush it to disk
     // (and make StartSync reload from disk).  This would require
     // refactoring TestUserShare.
   }
 
-  void UnloadBookmarkModel() {
-    profile_.CreateBookmarkModel(false /* delete_bookmarks */);
-    model_ = NULL;
-    base::MessageLoop::current()->RunUntilIdle();
-  }
-
   bool InitSyncNodeFromChromeNode(const BookmarkNode* bnode,
                                   BaseNode* sync_node) {
     return model_associator_->InitSyncNodeFromChromeId(bnode->id(),
                                                        sync_node);
   }
 
   void ExpectSyncerNodeMatching(syncer::BaseTransaction* trans,
                                 const BookmarkNode* bnode) {
     std::string truncated_title = base::UTF16ToUTF8(bnode->GetTitle());
     syncer::SyncAPINameToServerName(truncated_title, &truncated_title);
@@ skipping 113 matching lines @@
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(node);
     const BookmarkNode* parent =
         model_associator_->GetChromeNodeFromSyncId(parent_sync_id);
     EXPECT_TRUE(parent);
     EXPECT_EQ(node->parent(), parent);
   }
 
   void ExpectModelMatch(syncer::BaseTransaction* trans) {
     const BookmarkNode* root = model_->root_node();
-#if defined(OS_IOS) || defined(OS_ANDROID)
-    EXPECT_EQ(root->GetIndexOf(model_->mobile_node()), 0);
-    EXPECT_EQ(root->GetIndexOf(model_->bookmark_bar_node()), 1);
-    EXPECT_EQ(root->GetIndexOf(model_->other_node()), 2);
-#else
     EXPECT_EQ(root->GetIndexOf(model_->bookmark_bar_node()), 0);
     EXPECT_EQ(root->GetIndexOf(model_->other_node()), 1);
     EXPECT_EQ(root->GetIndexOf(model_->mobile_node()), 2);
-#endif  // defined(OS_IOS) || defined(OS_ANDROID)
 
     std::stack<int64_t> stack;
     stack.push(bookmark_bar_id());
     while (!stack.empty()) {
       int64_t id = stack.top();
       stack.pop();
       if (!id) continue;
 
       ExpectBrowserNodeMatching(trans, id);
 
@@ skipping 18 matching lines @@
   int64_t other_bookmarks_id() {
     return
         model_associator_->GetSyncIdFromChromeId(model_->other_node()->id());
   }
 
   int64_t bookmark_bar_id() {
     return model_associator_->GetSyncIdFromChromeId(
         model_->bookmark_bar_node()->id());
   }
 
-  BookmarkModel* model() { return model_; }
+  BookmarkModel* model() { return model_.get(); }
 
   syncer::TestUserShare* test_user_share() { return &test_user_share_; }
 
   BookmarkChangeProcessor* change_processor() {
     return change_processor_.get();
   }
 
   void delete_change_processor() { change_processor_.reset(); }
 
   void ResetChangeProcessor() {
     change_processor_ = make_scoped_ptr(new BookmarkChangeProcessor(
-        &sync_client_, model_associator_.get(), &mock_error_handler_));
+        sync_client_.get(), model_associator_.get(), &mock_error_handler_));
   }
 
   sync_driver::DataTypeErrorHandlerMock* mock_error_handler() {
     return &mock_error_handler_;
   }
 
   void delete_model_associator() { model_associator_.reset(); }
 
   BookmarkModelAssociator* model_associator() {
     return model_associator_.get();
   }
 
-  bookmarks::ManagedBookmarkService* GetManagedBookmarkService() {
-    return ManagedBookmarkServiceFactory::GetForProfile(&profile_);
+  bookmarks::ManagedBookmarkService* managed_bookmark_service() {
+    return managed_bookmark_service_.get();
   }
 
  private:
-  content::TestBrowserThreadBundle thread_bundle_;
+  base::ScopedTempDir data_dir_;
+  base::MessageLoop message_loop_;
+  browser_sync::ProfileSyncServiceBundle profile_sync_service_bundle_;
 
-  TestingProfile profile_;
-  TestSyncClient sync_client_;
-  BookmarkModel* model_;
+  scoped_ptr<sync_driver::FakeSyncClient> sync_client_;
+  scoped_ptr<BookmarkModel> model_;
   syncer::TestUserShare test_user_share_;
   scoped_ptr<BookmarkChangeProcessor> change_processor_;
   StrictMock<sync_driver::DataTypeErrorHandlerMock> mock_error_handler_;
   scoped_ptr<BookmarkModelAssociator> model_associator_;
+  scoped_ptr<bookmarks::ManagedBookmarkService> managed_bookmark_service_;
 
   syncer::SyncMergeResult local_merge_result_;
   syncer::SyncMergeResult syncer_merge_result_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceBookmarkTest);
 };
 
 TEST_F(ProfileSyncServiceBookmarkTest, InitialState) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
@@ skipping 1085 matching lines @@
   StartSync();
 
   WriteTestDataToBookmarkModel();
 
   ExpectModelMatch();
 
   // Force both models to discard their data and reload from disk.  This
   // simulates what would happen if the browser were to shutdown normally,
   // and then relaunch.
   StopSync();
-  UnloadBookmarkModel();
   LoadBookmarkModel(LOAD_FROM_STORAGE, SAVE_TO_STORAGE);
   StartSync();
 
   ExpectBookmarkModelMatchesTestData();
 
   // With the BookmarkModel contents verified, ExpectModelMatch will
   // verify the contents of the sync model.
   ExpectModelMatch();
 }
 
@@ skipping 25 matching lines @@
   StartSync();
 
   WriteTestDataToBookmarkModel();
 
   ExpectModelMatch();
 
   // Force the databse to unload and write itself to disk.
   StopSync();
 
   // Blow away the bookmark model -- it should be empty afterwards.
-  UnloadBookmarkModel();
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   EXPECT_EQ(model()->bookmark_bar_node()->child_count(), 0);
   EXPECT_EQ(model()->other_node()->child_count(), 0);
   EXPECT_EQ(model()->mobile_node()->child_count(), 0);
 
   // Now restart the sync service.  Starting it should populate the bookmark
   // model -- test for consistency.
   StartSync();
   ExpectBookmarkModelMatchesTestData();
   ExpectModelMatch();
 }
 
 // Tests the merge cases when both the models are expected to be identical
 // after the merge.
 TEST_F(ProfileSyncServiceBookmarkTestWithData, MergeExpectedIdenticalModels) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, SAVE_TO_STORAGE);
   StartSync();
   WriteTestDataToBookmarkModel();
   ExpectModelMatch();
   StopSync();
-  UnloadBookmarkModel();
 
   // At this point both the bookmark model and the server should have the
   // exact same data and it should match the test data.
   LoadBookmarkModel(LOAD_FROM_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
   ExpectBookmarkModelMatchesTestData();
   ExpectModelMatch();
   StopSync();
-  UnloadBookmarkModel();
 
   // Now reorder some bookmarks in the bookmark model and then merge. Make
   // sure we get the order of the server after merge.
   LoadBookmarkModel(LOAD_FROM_STORAGE, DONT_SAVE_TO_STORAGE);
   ExpectBookmarkModelMatchesTestData();
   const BookmarkNode* bookmark_bar = model()->bookmark_bar_node();
   ASSERT_TRUE(bookmark_bar);
   ASSERT_GT(bookmark_bar->child_count(), 1);
   model()->Move(bookmark_bar->GetChild(0), bookmark_bar, 1);
   StartSync();
@@ skipping 581 matching lines @@
 
 // Verify operations on native nodes that shouldn't be propagated to Sync.
 TEST_F(ProfileSyncServiceBookmarkTest, TestUnsupportedNodes) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
   // Initial number of bookmarks on the sync side.
   int sync_bookmark_count = GetSyncBookmarkCount();
 
   // Create a bookmark under managed_node() permanent folder.
-  bookmarks::ManagedBookmarkService* managed_bookmark_service =
-      GetManagedBookmarkService();
-  const BookmarkNode* folder = managed_bookmark_service->managed_node();
+  const BookmarkNode* folder = managed_bookmark_service()->managed_node();
   const BookmarkNode* node = model()->AddURL(
       folder, 0, base::ASCIIToUTF16("node"), GURL("http://www.node.com/"));
 
   // Verify that these changes are ignored by Sync.
   EXPECT_EQ(sync_bookmark_count, GetSyncBookmarkCount());
   int64_t sync_id = model_associator()->GetSyncIdFromChromeId(node->id());
   EXPECT_EQ(syncer::kInvalidId, sync_id);
 
   // Verify that Sync ignores deleting this node.
   model()->Remove(node);
   EXPECT_EQ(sync_bookmark_count, GetSyncBookmarkCount());
 }
 
 }  // namespace
 
 }  // namespace browser_sync