Componentize SyncBackendHostImpl unittest

components/sync_driver/glue/sync_backend_host_impl_unittest.cc

 // Copyright 2013 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/sync_driver/glue/sync_backend_host_impl.h"
 
 #include <cstddef>
 
 #include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
-#include "chrome/browser/sync/profile_sync_test_util.h"
-#include "chrome/test/base/testing_browser_process.h"
-#include "chrome/test/base/testing_profile.h"
-#include "chrome/test/base/testing_profile_manager.h"
 #include "components/invalidation/impl/invalidator_storage.h"
 #include "components/invalidation/impl/profile_invalidation_provider.h"
 #include "components/invalidation/public/invalidator_state.h"
 #include "components/invalidation/public/object_id_invalidation_map.h"
 #include "components/sync_driver/device_info.h"
 #include "components/sync_driver/fake_sync_client.h"
 #include "components/sync_driver/sync_frontend.h"
 #include "components/sync_driver/sync_prefs.h"
 #include "components/syncable_prefs/pref_service_syncable.h"
-#include "content/public/browser/notification_service.h"
-#include "content/public/test/test_browser_thread_bundle.h"
-#include "content/public/test/test_utils.h"
+#include "components/syncable_prefs/testing_pref_service_syncable.h"
 #include "google/cacheinvalidation/include/types.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/internal_api/public/engine/passive_model_worker.h"
 #include "sync/internal_api/public/http_bridge_network_resources.h"
 #include "sync/internal_api/public/network_resources.h"
 #include "sync/internal_api/public/sessions/commit_counters.h"
 #include "sync/internal_api/public/sessions/status_counters.h"
 #include "sync/internal_api/public/sessions/update_counters.h"
 #include "sync/internal_api/public/sync_manager_factory.h"
 #include "sync/internal_api/public/test/fake_sync_manager.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/protocol/encryption.pb.h"
 #include "sync/protocol/sync_protocol_error.h"
 #include "sync/test/callback_counter.h"
 #include "sync/util/test_unrecoverable_error_handler.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
-using content::BrowserThread;
 using syncer::FakeSyncManager;
 using syncer::SyncManager;
 using ::testing::InvokeWithoutArgs;
 using ::testing::StrictMock;
 using ::testing::_;
 
 namespace browser_sync {
 
 namespace {
 
-const char kTestProfileName[] = "test-profile";
-
 static const base::FilePath::CharType kTestSyncDir[] =
     FILE_PATH_LITERAL("sync-test");
 
 ACTION_P(Signal, event) {
   event->Signal();
 }
 
+void EmptyNetworkTimeUpdate(const base::Time&,
+                            const base::TimeDelta&,
+                            const base::TimeDelta&) {}
+
 void QuitMessageLoop() {
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
 class MockSyncFrontend : public sync_driver::SyncFrontend {
  public:
   virtual ~MockSyncFrontend() {}
 
   MOCK_METHOD4(
       OnBackendInitialized,
@@ skipping 78 matching lines @@
         return new syncer::PassiveModelWorker(observer);
       default:
         return nullptr;
     }
   }
 };
 
 class SyncBackendHostTest : public testing::Test {
  protected:
   SyncBackendHostTest()
-      : thread_bundle_(content::TestBrowserThreadBundle::REAL_IO_THREAD),
-        profile_manager_(TestingBrowserProcess::GetGlobal()),
-        fake_manager_(NULL) {}
+      : fake_manager_(NULL) {
+   }
 
   ~SyncBackendHostTest() override {}
 
   void SetUp() override {
-    ASSERT_TRUE(profile_manager_.SetUp());
-    profile_ = profile_manager_.CreateTestingProfile(kTestProfileName);
-    sync_prefs_.reset(new sync_driver::SyncPrefs(profile_->GetPrefs()));
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+
+    sync_driver::SyncPrefs::RegisterProfilePrefs(pref_service_.registry());
+
+    sync_prefs_.reset(new sync_driver::SyncPrefs(&pref_service_));
     backend_.reset(new SyncBackendHostImpl(
-        profile_->GetDebugName(), &sync_client_,
-        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
-        invalidation::ProfileInvalidationProviderFactory::GetForProfile(
-            profile_)
-            ->GetInvalidationService(),
+        "dummyDebugName", &sync_client_,
+        base::ThreadTaskRunnerHandle::Get(),
+        nullptr,
         sync_prefs_->AsWeakPtr(),
-        profile_->GetPath().Append(base::FilePath(kTestSyncDir))));
+        temp_dir_.path().Append(base::FilePath(kTestSyncDir))));
     credentials_.email = "user@example.com";
     credentials_.sync_token = "sync_token";
     credentials_.scope_set.insert(GaiaConstants::kChromeSyncOAuth2Scope);
 
     fake_manager_factory_.reset(new FakeSyncManagerFactory(&fake_manager_));
 
     // These types are always implicitly enabled.
     enabled_types_.PutAll(syncer::ControlTypes());
 
     // NOTE: We can't include Passwords or Typed URLs due to the Sync Backend
     // Registrar removing them if it can't find their model workers.
     enabled_types_.Put(syncer::BOOKMARKS);
     enabled_types_.Put(syncer::PREFERENCES);
     enabled_types_.Put(syncer::SESSIONS);
     enabled_types_.Put(syncer::SEARCH_ENGINES);
     enabled_types_.Put(syncer::AUTOFILL);
 
     network_resources_.reset(new syncer::HttpBridgeNetworkResources());
   }
 
   void TearDown() override {
     if (backend_) {
       backend_->StopSyncingForShutdown();
       backend_->Shutdown(syncer::STOP_SYNC);
     }
     backend_.reset();
     sync_prefs_.reset();
-    profile_ = NULL;
-    profile_manager_.DeleteTestingProfile(kTestProfileName);
-    // Pump messages posted by the sync thread (which may end up
-    // posting on the IO thread).
-    base::RunLoop().RunUntilIdle();
-    content::RunAllPendingInMessageLoop(BrowserThread::IO);
-    // Pump any messages posted by the IO thread.
+    // Pump messages posted by the sync thread.
     base::RunLoop().RunUntilIdle();
   }
 
   // Synchronously initializes the backend.
   void InitializeBackend(bool expect_success) {
     EXPECT_CALL(mock_frontend_, OnBackendInitialized(_, _, _, expect_success)).
         WillOnce(InvokeWithoutArgs(QuitMessageLoop));
     SyncBackendHost::HttpPostProviderFactoryGetter
         http_post_provider_factory_getter =
             base::Bind(&syncer::NetworkResources::GetHttpPostProviderFactory,
                        base::Unretained(network_resources_.get()),
-                       make_scoped_refptr(profile_->GetRequestContext()),
+                       nullptr,
                        base::Bind(&EmptyNetworkTimeUpdate));
     backend_->Initialize(
         &mock_frontend_, scoped_ptr<base::Thread>(),
-        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB),
-        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
+        base::ThreadTaskRunnerHandle::Get(),
+        base::ThreadTaskRunnerHandle::Get(),
         syncer::WeakHandle<syncer::JsEventHandler>(), GURL(std::string()),
         std::string(), credentials_, true, fake_manager_factory_.Pass(),
         MakeWeakHandle(test_unrecoverable_error_handler_.GetWeakPtr()),
         base::Closure(), http_post_provider_factory_getter,
         saved_nigori_state_.Pass());
     base::RunLoop run_loop;
-    BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
-                                   run_loop.QuitClosure(),
-                                   TestTimeouts::action_timeout());
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE,
+        run_loop.QuitClosure(),
+        TestTimeouts::action_timeout());
     run_loop.Run();
     // |fake_manager_factory_|'s fake_manager() is set on the sync
     // thread, but we can rely on the message loop barriers to
     // guarantee that we see the updated value.
     DCHECK(fake_manager_);
   }
 
   // Synchronously configures the backend's datatypes.
   syncer::ModelTypeSet ConfigureDataTypes(
       syncer::ModelTypeSet types_to_add,
@@ skipping 12 matching lines @@
         sync_driver::BackendDataTypeConfigurer::UNREADY,
         types_to_unapply, &config_state_map);
 
     types_to_add.PutAll(syncer::ControlTypes());
     syncer::ModelTypeSet ready_types = backend_->ConfigureDataTypes(
         syncer::CONFIGURE_REASON_RECONFIGURATION, config_state_map,
         base::Bind(&SyncBackendHostTest::DownloadReady, base::Unretained(this)),
         base::Bind(&SyncBackendHostTest::OnDownloadRetry,
                    base::Unretained(this)));
     base::RunLoop run_loop;
-    BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
-                                   run_loop.QuitClosure(),
-                                   TestTimeouts::action_timeout());
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE,
+        run_loop.QuitClosure(),
+        TestTimeouts::action_timeout());
     run_loop.Run();
     return ready_types;
   }
 
  protected:
   void DownloadReady(syncer::ModelTypeSet succeeded_types,
                      syncer::ModelTypeSet failed_types) {
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void OnDownloadRetry() {
     NOTIMPLEMENTED();
   }
 
-  content::TestBrowserThreadBundle thread_bundle_;
+  base::MessageLoop message_loop_;
+  base::ScopedTempDir temp_dir_;
+  syncable_prefs::TestingPrefServiceSyncable pref_service_;
   StrictMock<MockSyncFrontend> mock_frontend_;
   syncer::SyncCredentials credentials_;
-  TestingProfileManager profile_manager_;
-  TestingProfile* profile_;
   BackendSyncClient sync_client_;
   syncer::TestUnrecoverableErrorHandler test_unrecoverable_error_handler_;
   scoped_ptr<sync_driver::SyncPrefs> sync_prefs_;
   scoped_ptr<SyncBackendHostImpl> backend_;
   scoped_ptr<FakeSyncManagerFactory> fake_manager_factory_;
   FakeSyncManager* fake_manager_;
   syncer::ModelTypeSet enabled_types_;
   scoped_ptr<syncer::NetworkResources> network_resources_;
   scoped_ptr<syncer::SyncEncryptionHandler::NigoriState> saved_nigori_state_;
 };
@@ skipping 416 matching lines @@
   fake_manager_factory_->set_initial_sync_ended_types(enabled_types_);
   InitializeBackend(true);
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE,
             fake_manager_->GetAndResetConfigureReason());
 }
 
 // It is SyncBackendHostCore responsibility to cleanup Sync Data folder if sync
 // setup hasn't been completed. This test ensures that cleanup happens.
 TEST_F(SyncBackendHostTest, TestStartupWithOldSyncData) {
   const char* nonsense = "slon";
-  base::FilePath temp_directory =
-      profile_->GetPath().Append(base::FilePath(kTestSyncDir));
+  base::FilePath temp_directory = temp_dir_.path().Append(
+      base::FilePath(kTestSyncDir));
   base::FilePath sync_file = temp_directory.AppendASCII("SyncData.sqlite3");
   ASSERT_TRUE(base::CreateDirectory(temp_directory));
   ASSERT_NE(-1, base::WriteFile(sync_file, nonsense, strlen(nonsense)));
 
   InitializeBackend(true);
 
   EXPECT_FALSE(base::PathExists(sync_file));
 }
 
 // If bookmarks encounter an error that results in disabling without purging
@@ skipping 103 matching lines @@
   EXPECT_EQ(invalidation_versions.size(),
             persisted_invalidation_versions.size());
   for (auto iter : persisted_invalidation_versions) {
     EXPECT_EQ(invalidation_versions[iter.first], iter.second);
   }
 }
 
 }  // namespace
 
 }  // namespace browser_sync