Remove //chrome and //content deps from ProfileSyncServiceBookmarkTest

components/browser_sync/browser/profile_sync_test_util.cc

 // Copyright 2016 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 "components/browser_sync/browser/profile_sync_test_util.h"
 
+#include "components/bookmarks/browser/bookmark_model.h"
 #include "components/history/core/browser/history_model_worker.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/sync_driver/glue/browser_thread_model_worker.h"
 #include "components/sync_driver/glue/ui_model_worker.h"
 #include "components/sync_driver/signin_manager_wrapper.h"
 #include "components/sync_driver/sync_prefs.h"
 #include "net/url_request/url_request_test_util.h"
 #include "sync/internal_api/public/engine/passive_model_worker.h"
 
 using sync_driver::ClearBrowsingDataCallback;
 
 namespace browser_sync {
 
 namespace {
 
 class BundleSyncClient : public sync_driver::FakeSyncClient {
  public:
   BundleSyncClient(
       sync_driver::SyncApiComponentFactory* factory,
       PrefService* pref_service,
       const ClearBrowsingDataCallback& clear_browsing_data_callback,
       sync_sessions::SyncSessionsClient* sync_sessions_client,
       autofill::PersonalDataManager* personal_data_manager,
       const base::Callback<base::WeakPtr<syncer::SyncableService>(
           syncer::ModelType type)>& get_syncable_service_callback,
       const base::Callback<sync_driver::SyncService*(void)>&
           get_sync_service_callback,
+      const base::Callback<bookmarks::BookmarkModel*(void)>&
+          get_bookmark_model_callback,
       scoped_refptr<base::SingleThreadTaskRunner> db_thread,
       scoped_refptr<base::SingleThreadTaskRunner> file_thread,
       history::HistoryService* history_service);
 
   ~BundleSyncClient() override;
 
   PrefService* GetPrefService() override;
   ClearBrowsingDataCallback GetClearBrowsingDataCallback() override;
   sync_sessions::SyncSessionsClient* GetSyncSessionsClient() override;
   autofill::PersonalDataManager* GetPersonalDataManager() override;
   base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
       syncer::ModelType type) override;
   sync_driver::SyncService* GetSyncService() override;
   scoped_refptr<syncer::ModelSafeWorker> CreateModelWorkerForGroup(
       syncer::ModelSafeGroup group,
       syncer::WorkerLoopDestructionObserver* observer) override;
   history::HistoryService* GetHistoryService() override;
+  bookmarks::BookmarkModel* GetBookmarkModel() override;
 
  private:
   PrefService* const pref_service_;
   const ClearBrowsingDataCallback clear_browsing_data_callback_;
   sync_sessions::SyncSessionsClient* const sync_sessions_client_;
   autofill::PersonalDataManager* const personal_data_manager_;
   const base::Callback<base::WeakPtr<syncer::SyncableService>(
       syncer::ModelType type)>
       get_syncable_service_callback_;
   const base::Callback<sync_driver::SyncService*(void)>
       get_sync_service_callback_;
+  const base::Callback<bookmarks::BookmarkModel*(void)>
+      get_bookmark_model_callback_;
   // These task runners, if not null, are used in CreateModelWorkerForGroup.
   const scoped_refptr<base::SingleThreadTaskRunner> db_thread_;
   const scoped_refptr<base::SingleThreadTaskRunner> file_thread_;
   history::HistoryService* history_service_;
 };
 
 BundleSyncClient::BundleSyncClient(
     sync_driver::SyncApiComponentFactory* factory,
     PrefService* pref_service,
     const ClearBrowsingDataCallback& clear_browsing_data_callback,
     sync_sessions::SyncSessionsClient* sync_sessions_client,
     autofill::PersonalDataManager* personal_data_manager,
     const base::Callback<base::WeakPtr<syncer::SyncableService>(
         syncer::ModelType type)>& get_syncable_service_callback,
     const base::Callback<sync_driver::SyncService*(void)>&
         get_sync_service_callback,
+    const base::Callback<bookmarks::BookmarkModel*(void)>&
+        get_bookmark_model_callback,
     scoped_refptr<base::SingleThreadTaskRunner> db_thread,
     scoped_refptr<base::SingleThreadTaskRunner> file_thread,
     history::HistoryService* history_service)
     : sync_driver::FakeSyncClient(factory),
       pref_service_(pref_service),
       clear_browsing_data_callback_(clear_browsing_data_callback),
       sync_sessions_client_(sync_sessions_client),
       personal_data_manager_(personal_data_manager),
       get_syncable_service_callback_(get_syncable_service_callback),
       get_sync_service_callback_(get_sync_service_callback),
+      get_bookmark_model_callback_(get_bookmark_model_callback),
       db_thread_(db_thread),
       file_thread_(file_thread),
       history_service_(history_service) {
   DCHECK_EQ(!!db_thread_, !!file_thread_);
 }
 
 BundleSyncClient::~BundleSyncClient() = default;
 
 PrefService* BundleSyncClient::GetPrefService() {
   return pref_service_;
@@ skipping 54 matching lines @@
       return nullptr;
   }
 }
 
 history::HistoryService* BundleSyncClient::GetHistoryService() {
   if (history_service_)
     return history_service_;
   return FakeSyncClient::GetHistoryService();
 }
 
+bookmarks::BookmarkModel* BundleSyncClient::GetBookmarkModel() {
+  if (get_bookmark_model_callback_.is_null())
+    return FakeSyncClient::GetBookmarkModel();
+  return get_bookmark_model_callback_.Run();
+}
+
 }  // namespace
 
 void EmptyNetworkTimeUpdate(const base::Time&,
                             const base::TimeDelta&,
                             const base::TimeDelta&) {}
 
 void RegisterPrefsForProfileSyncService(
     user_prefs::PrefRegistrySyncable* registry) {
   sync_driver::SyncPrefs::RegisterProfilePrefs(registry);
   AccountTrackerService::RegisterPrefs(registry);
@@ skipping 29 matching lines @@
     const base::Callback<sync_driver::SyncService*(void)>&
         get_sync_service_callback) {
   get_sync_service_callback_ = get_sync_service_callback;
 }
 
 void ProfileSyncServiceBundle::SyncClientBuilder::SetHistoryService(
     history::HistoryService* history_service) {
   history_service_ = history_service;
 }
 
+void ProfileSyncServiceBundle::SyncClientBuilder::SetBookmarkModelCallback(
+    const base::Callback<bookmarks::BookmarkModel*(void)>&
+        get_bookmark_model_callback) {
+  get_bookmark_model_callback_ = get_bookmark_model_callback;
+}
+
 scoped_ptr<sync_driver::FakeSyncClient>
 ProfileSyncServiceBundle::SyncClientBuilder::Build() {
   return make_scoped_ptr(new BundleSyncClient(
       bundle_->component_factory(), bundle_->pref_service(),
       clear_browsing_data_callback_, bundle_->sync_sessions_client(),
       personal_data_manager_, get_syncable_service_callback_,
-      get_sync_service_callback_,
+      get_sync_service_callback_, get_bookmark_model_callback_,
       activate_model_creation_ ? bundle_->db_thread() : nullptr,
       activate_model_creation_ ? base::ThreadTaskRunnerHandle::Get() : nullptr,
       history_service_));
 }
 
 ProfileSyncServiceBundle::ProfileSyncServiceBundle()
     : db_thread_(base::ThreadTaskRunnerHandle::Get()),
       worker_pool_owner_(2, "sync test worker pool"),
       signin_client_(&pref_service_),
 #if defined(OS_CHROMEOS)
@@ skipping 31 matching lines @@
   init_params.debug_identifier = "dummyDebugName";
   init_params.channel = version_info::Channel::UNKNOWN;
   init_params.db_thread = db_thread_;
   init_params.file_thread = base::ThreadTaskRunnerHandle::Get();
   init_params.blocking_pool = worker_pool_owner_.pool().get();
 
   return init_params;
 }
 
 }  // namespace browser_sync