Clean up TestProfileSyncService and related tests

chrome/browser/sync/test_profile_sync_service.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/sync/test_profile_sync_service.h"
 
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/glue/sync_backend_host_core.h"
 #include "chrome/browser/sync/profile_sync_components_factory.h"
+#include "chrome/browser/sync/profile_sync_components_factory_mock.h"
 #include "chrome/browser/sync/test/test_http_bridge_factory.h"
 #include "sync/internal_api/public/test/sync_manager_factory_for_profile_sync_test.h"
+#include "sync/internal_api/public/test/test_internal_components_factory.h"
 #include "sync/internal_api/public/user_share.h"
 #include "sync/js/js_reply_handler.h"
 #include "sync/protocol/encryption.pb.h"
 
 using syncer::InternalComponentsFactory;
-using syncer::ModelSafeRoutingInfo;
 using syncer::TestInternalComponentsFactory;
 using syncer::UserShare;
 
 namespace browser_sync {
 
 SyncBackendHostForProfileSyncTest::SyncBackendHostForProfileSyncTest(
     Profile* profile,
     const base::WeakPtr<SyncPrefs>& sync_prefs,
-    base::Closure& callback,
-    bool set_initial_sync_ended_on_init,
-    bool synchronous_init,
-    bool fail_initial_download,
-    syncer::StorageOption storage_option)
+    base::Closure& callback)
     : browser_sync::SyncBackendHostImpl(
         profile->GetDebugName(), profile, sync_prefs),
-      callback_(callback),
-      fail_initial_download_(fail_initial_download),
-      set_initial_sync_ended_on_init_(set_initial_sync_ended_on_init),
-      synchronous_init_(synchronous_init),
-      storage_option_(storage_option),
-      weak_ptr_factory_(this) {}
+    callback_(callback) {}
 
 SyncBackendHostForProfileSyncTest::~SyncBackendHostForProfileSyncTest() {}
 
-namespace {
-
-scoped_ptr<syncer::HttpPostProviderFactory> MakeTestHttpBridgeFactory() {
-  return scoped_ptr<syncer::HttpPostProviderFactory>(
-      new browser_sync::TestHttpBridgeFactory());
-}
-
-}  // namespace
-
 void SyncBackendHostForProfileSyncTest::InitCore(
     scoped_ptr<DoInitializeOptions> options) {
-  options->http_bridge_factory = MakeTestHttpBridgeFactory();
+  options->http_bridge_factory =
+      scoped_ptr<syncer::HttpPostProviderFactory>(
+          new browser_sync::TestHttpBridgeFactory());
   options->sync_manager_factory.reset(
-      new syncer::SyncManagerFactoryForProfileSyncTest(
-          callback_,
-          set_initial_sync_ended_on_init_));
+      new syncer::SyncManagerFactoryForProfileSyncTest(callback_));
   options->credentials.email = "testuser@gmail.com";
   options->credentials.sync_token = "token";
   options->restored_key_for_bootstrapping = "";
-  syncer::StorageOption storage = storage_option_;
 
   // It'd be nice if we avoided creating the InternalComponentsFactory in the
   // first place, but SyncBackendHost will have created one by now so we must
   // free it. Grab the switches to pass on first.
   InternalComponentsFactory::Switches factory_switches =
       options->internal_components_factory->GetSwitches();
   options->internal_components_factory.reset(
-      new TestInternalComponentsFactory(factory_switches, storage));
+      new TestInternalComponentsFactory(factory_switches,
+                                        syncer::STORAGE_IN_MEMORY));
 
   SyncBackendHostImpl::InitCore(options.Pass());
-  if (synchronous_init_ && !base::MessageLoop::current()->is_running()) {
-    // The SyncBackend posts a task to the current loop when
-    // initialization completes.
-    base::MessageLoop::current()->Run();
-  }
-}
-
-void SyncBackendHostForProfileSyncTest::UpdateCredentials(
-      const syncer::SyncCredentials& credentials) {
-  // If we had failed the initial download, complete initialization now.
-  if (!initial_download_closure_.is_null()) {
-    initial_download_closure_.Run();
-    initial_download_closure_.Reset();
-  }
 }
 
 void SyncBackendHostForProfileSyncTest::RequestConfigureSyncer(
     syncer::ConfigureReason reason,
     syncer::ModelTypeSet to_download,
     syncer::ModelTypeSet to_purge,
     syncer::ModelTypeSet to_journal,
     syncer::ModelTypeSet to_unapply,
     syncer::ModelTypeSet to_ignore,
     const syncer::ModelSafeRoutingInfo& routing_info,
     const base::Callback<void(syncer::ModelTypeSet,
                               syncer::ModelTypeSet)>& ready_task,
     const base::Closure& retry_callback) {
   syncer::ModelTypeSet failed_configuration_types;
-  if (fail_initial_download_)
-    failed_configuration_types = to_download;
 
   // The first parameter there should be the set of enabled types.  That's not
   // something we have access to from this strange test harness.  We'll just
   // send back the list of newly configured types instead and hope it doesn't
   // break anything.
   FinishConfigureDataTypesOnFrontendLoop(
       syncer::Difference(to_download, failed_configuration_types),
       syncer::Difference(to_download, failed_configuration_types),
       failed_configuration_types,
       ready_task);
 }
 
-void
-SyncBackendHostForProfileSyncTest::HandleInitializationSuccessOnFrontendLoop(
-    const syncer::WeakHandle<syncer::JsBackend> js_backend,
-    const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>
-    debug_info_listener) {
-  if (fail_initial_download_) {
-    // We interrupt this successful init to bring you a simulated failure.
-    initial_download_closure_ = base::Bind(
-        &SyncBackendHostForProfileSyncTest::
-            HandleInitializationSuccessOnFrontendLoop,
-        weak_ptr_factory_.GetWeakPtr(),
-        js_backend,
-        debug_info_listener);
-    HandleControlTypesDownloadRetry();
-    if (synchronous_init_)
-      base::MessageLoop::current()->Quit();
-  } else {
-    SyncBackendHostImpl::HandleInitializationSuccessOnFrontendLoop(
-        js_backend,
-        debug_info_listener);
-  }
-}
-
 }  // namespace browser_sync
 
 syncer::TestIdFactory* TestProfileSyncService::id_factory() {
   return &id_factory_;
 }
 
-browser_sync::SyncBackendHostForProfileSyncTest*
-    TestProfileSyncService::GetBackendForTest() {
-  return static_cast<browser_sync::SyncBackendHostForProfileSyncTest*>(
-      ProfileSyncService::GetBackendForTest());
-}
-
 syncer::WeakHandle<syncer::JsEventHandler>
 TestProfileSyncService::GetJsEventHandler() {
   return syncer::WeakHandle<syncer::JsEventHandler>();
 }
 
 TestProfileSyncService::TestProfileSyncService(
     ProfileSyncComponentsFactory* factory,
     Profile* profile,
     SigninManagerBase* signin,
     ProfileOAuth2TokenService* oauth2_token_service,
-    ProfileSyncService::StartBehavior behavior,
-    bool synchronous_backend_initialization)
+    ProfileSyncService::StartBehavior behavior)
         : ProfileSyncService(factory,
                              profile,
                              signin,
                              oauth2_token_service,
-                             behavior),
-    synchronous_backend_initialization_(
-        synchronous_backend_initialization),
-    synchronous_sync_configuration_(false),
-    set_initial_sync_ended_on_init_(true),
-    fail_initial_download_(false),
-    storage_option_(syncer::STORAGE_IN_MEMORY) {
+                             behavior) {
   SetSyncSetupCompleted();
 }
 
 TestProfileSyncService::~TestProfileSyncService() {
 }
 
 // static
 BrowserContextKeyedService* TestProfileSyncService::BuildAutoStartAsyncInit(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
   SigninManagerBase* signin =
       SigninManagerFactory::GetForProfile(profile);
   ProfileOAuth2TokenService* oauth2_token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
   ProfileSyncComponentsFactoryMock* factory =
       new ProfileSyncComponentsFactoryMock();
   return new TestProfileSyncService(factory,
                                     profile,
                                     signin,
                                     oauth2_token_service,
-                                    ProfileSyncService::AUTO_START,
-                                    false);
+                                    ProfileSyncService::AUTO_START);
 }
 
 ProfileSyncComponentsFactoryMock*
 TestProfileSyncService::components_factory_mock() {
   // We always create a mock factory, see Build* routines.
   return static_cast<ProfileSyncComponentsFactoryMock*>(factory());
 }
 
-void TestProfileSyncService::RequestAccessToken() {
-  ProfileSyncService::RequestAccessToken();
-  if (synchronous_backend_initialization_) {
-    base::MessageLoop::current()->Run();
-  }
-}
-
-void TestProfileSyncService::OnGetTokenSuccess(
-    const OAuth2TokenService::Request* request,
-    const std::string& access_token,
-    const base::Time& expiration_time) {
-  ProfileSyncService::OnGetTokenSuccess(request, access_token,
-                                        expiration_time);
-  if (synchronous_backend_initialization_) {
-    base::MessageLoop::current()->Quit();
-  }
-}
-
-void TestProfileSyncService::OnGetTokenFailure(
-    const OAuth2TokenService::Request* request,
-    const GoogleServiceAuthError& error) {
-  ProfileSyncService::OnGetTokenFailure(request, error);
-  if (synchronous_backend_initialization_) {
-    base::MessageLoop::current()->Quit();
-  }
-}
-
-
-void TestProfileSyncService::OnBackendInitialized(
-    const syncer::WeakHandle<syncer::JsBackend>& backend,
-    const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
-        debug_info_listener,
-    bool success) {
-  ProfileSyncService::OnBackendInitialized(backend,
-                                           debug_info_listener,
-                                           success);
-
-  // TODO(akalin): Figure out a better way to do this.
-  if (synchronous_backend_initialization_) {
-    base::MessageLoop::current()->Quit();
-  }
-}
-
 void TestProfileSyncService::OnConfigureDone(
     const browser_sync::DataTypeManager::ConfigureResult& result) {
   ProfileSyncService::OnConfigureDone(result);
-  if (!synchronous_sync_configuration_)
-    base::MessageLoop::current()->Quit();
+  base::MessageLoop::current()->Quit();
 }
 
 UserShare* TestProfileSyncService::GetUserShare() const {
   return backend_->GetUserShare();
 }
 
-void TestProfileSyncService::dont_set_initial_sync_ended_on_init() {
-  set_initial_sync_ended_on_init_ = false;
-}
-void TestProfileSyncService::set_synchronous_sync_configuration() {
-  synchronous_sync_configuration_ = true;
-}
-void TestProfileSyncService::fail_initial_download() {
-  fail_initial_download_ = true;
-}
-void TestProfileSyncService::set_storage_option(
-    syncer::StorageOption storage_option) {
-  storage_option_ = storage_option;
-}
-
 void TestProfileSyncService::CreateBackend() {
   backend_.reset(new browser_sync::SyncBackendHostForProfileSyncTest(
       profile(),
       sync_prefs_.AsWeakPtr(),
-      callback_,
-      set_initial_sync_ended_on_init_,
-      synchronous_backend_initialization_,
-      fail_initial_download_,
-      storage_option_));
+      callback_));
 }