[Sync] Fix auth error handling while the backend is initializing.

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/signin/signin_manager.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/profile_sync_components_factory.h"
@@ skipping 25 matching lines @@
     const base::WeakPtr<SyncPrefs>& sync_prefs,
     const base::WeakPtr<InvalidatorStorage>& invalidator_storage,
     syncer::TestIdFactory& id_factory,
     base::Closure& callback,
     bool set_initial_sync_ended_on_init,
     bool synchronous_init,
     bool fail_initial_download,
     syncer::StorageOption storage_option)
     : browser_sync::SyncBackendHost(
         profile->GetDebugName(), profile, sync_prefs, invalidator_storage),
+      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       id_factory_(id_factory),
       callback_(callback),
+      fail_initial_download_(fail_initial_download),
       set_initial_sync_ended_on_init_(set_initial_sync_ended_on_init),
       synchronous_init_(synchronous_init),
-      fail_initial_download_(fail_initial_download),
       storage_option_(storage_option) {}
 
 SyncBackendHostForProfileSyncTest::~SyncBackendHostForProfileSyncTest() {}
 
 namespace {
 
 scoped_ptr<syncer::HttpPostProviderFactory> MakeTestHttpBridgeFactory() {
   return scoped_ptr<syncer::HttpPostProviderFactory>(
       new browser_sync::TestHttpBridgeFactory());
 }
@@ skipping 21 matching lines @@
       new TestInternalComponentsFactory(factory_switches, storage);
 
   SyncBackendHost::InitCore(test_options);
   if (synchronous_init_) {
     // The SyncBackend posts a task to the current loop when
     // initialization completes.
     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 types_to_config,
     const syncer::ModelSafeRoutingInfo& routing_info,
     const base::Callback<void(syncer::ModelTypeSet)>& ready_task,
     const base::Closure& retry_callback) {
   syncer::ModelTypeSet failed_configuration_types;
   if (fail_initial_download_)
     failed_configuration_types = types_to_config;
 
   FinishConfigureDataTypesOnFrontendLoop(failed_configuration_types,
                                          ready_task);
 }
 
 void SyncBackendHostForProfileSyncTest
-        ::HandleSyncManagerInitializationOnFrontendLoop(
+    ::HandleSyncManagerInitializationOnFrontendLoop(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     syncer::ModelTypeSet restored_types) {
   // Here's our opportunity to pretend to do things that the SyncManager would
   // normally do during initialization, but can't because this is a test.
   // Set up any nodes the test wants around before model association.
   if (!callback_.is_null()) {
     callback_.Run();
   }
@@ skipping 16 matching lines @@
     }
 
     if (!directory->initial_sync_ended_for_type(EXPERIMENTS)) {
       syncer::TestUserShare::CreateRoot(EXPERIMENTS, user_share);
     }
 
     SetInitialSyncEndedForAllTypes();
     restored_types = syncer::ModelTypeSet::All();
   }
 
-  SyncBackendHost::HandleSyncManagerInitializationOnFrontendLoop(
-      js_backend, debug_info_listener, restored_types);
+  initial_download_closure_ = base::Bind(
+      &SyncBackendHostForProfileSyncTest::ContinueInitialization,
+      weak_ptr_factory_.GetWeakPtr(),
+      js_backend,
+      debug_info_listener,
+      restored_types);
+  if (fail_initial_download_) {
+    frontend()->OnSyncConfigureRetry();
+    if (synchronous_init_)
+      MessageLoop::current()->Quit();
+  } else {
+    initial_download_closure_.Run();
+    initial_download_closure_.Reset();
+  }
 }
 
 void SyncBackendHostForProfileSyncTest::SetInitialSyncEndedForAllTypes() {
   UserShare* user_share = GetUserShare();
   Directory* directory = user_share->directory.get();
 
   for (int i = syncer::FIRST_REAL_MODEL_TYPE;
        i < syncer::MODEL_TYPE_COUNT; ++i) {
     directory->set_initial_sync_ended_for_type(
         syncer::ModelTypeFromInt(i), true);
   }
 }
 
 void SyncBackendHostForProfileSyncTest::EmitOnInvalidatorStateChange(
     syncer::InvalidatorState state) {
   frontend()->OnInvalidatorStateChange(state);
 }
 
 void SyncBackendHostForProfileSyncTest::EmitOnIncomingInvalidation(
     const syncer::ObjectIdInvalidationMap& invalidation_map,
     const syncer::IncomingInvalidationSource source) {
   frontend()->OnIncomingInvalidation(invalidation_map, source);
 }
 
+void SyncBackendHostForProfileSyncTest::ContinueInitialization(
+    const syncer::WeakHandle<syncer::JsBackend>& js_backend,
+    const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
+        debug_info_listener,
+    syncer::ModelTypeSet restored_types) {
+  SyncBackendHost::HandleSyncManagerInitializationOnFrontendLoop(
+      js_backend, debug_info_listener, restored_types);
+}
+
 }  // namespace browser_sync
 
 syncer::TestIdFactory* TestProfileSyncService::id_factory() {
   return &id_factory_;
 }
 
 browser_sync::SyncBackendHostForProfileSyncTest*
     TestProfileSyncService::GetBackendForTest() {
   return static_cast<browser_sync::SyncBackendHostForProfileSyncTest*>(
       ProfileSyncService::GetBackendForTest());
@@ skipping 68 matching lines @@
       profile(),
       sync_prefs_.AsWeakPtr(),
       invalidator_storage_.AsWeakPtr(),
       id_factory_,
       callback_,
       set_initial_sync_ended_on_init_,
       synchronous_backend_initialization_,
       fail_initial_download_,
       storage_option_));
 }