[Sync] Handle errors during first sync gracefully.

chrome/browser/sync/glue/sync_backend_host.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 "build/build_config.h"
 
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 406 matching lines @@
   registrar_.reset();
   frontend_ = NULL;
   core_ = NULL;  // Releases reference to core_.
 }
 
 void SyncBackendHost::ConfigureDataTypes(
     syncable::ModelTypeSet types_to_add,
     syncable::ModelTypeSet types_to_remove,
     sync_api::ConfigureReason reason,
     base::Callback<void(syncable::ModelTypeSet)> ready_task,
+    base::Callback<void()> retry_callback,
     bool enable_nigori) {
   syncable::ModelTypeSet types_to_add_with_nigori = types_to_add;
   syncable::ModelTypeSet types_to_remove_with_nigori = types_to_remove;
   if (enable_nigori) {
     types_to_add_with_nigori.Put(syncable::NIGORI);
     types_to_remove_with_nigori.Remove(syncable::NIGORI);
   } else {
     types_to_add_with_nigori.Remove(syncable::NIGORI);
     types_to_remove_with_nigori.Put(syncable::NIGORI);
   }
   // Only one configure is allowed at a time.
   DCHECK(!pending_config_mode_state_.get());
   DCHECK(!pending_download_state_.get());
   DCHECK_GT(initialization_state_, NOT_INITIALIZED);
 
   pending_config_mode_state_.reset(new PendingConfigureDataTypesState());
   pending_config_mode_state_->ready_task = ready_task;
   pending_config_mode_state_->types_to_add = types_to_add_with_nigori;
   pending_config_mode_state_->added_types =
       registrar_->ConfigureDataTypes(types_to_add_with_nigori,
                                      types_to_remove_with_nigori);
   pending_config_mode_state_->reason = reason;
+  pending_config_mode_state_->retry_callback = retry_callback;
 
   // Cleanup disabled types before starting configuration so that
   // callers can assume that the data types are cleaned up once
   // configuration is done.
   if (!types_to_remove_with_nigori.Empty()) {
     sync_thread_.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&SyncBackendHost::Core::DoRequestCleanupDisabledTypes,
                    core_.get()));
   }
@@ skipping 116 matching lines @@
 
   // Process any changes to the datatypes we're syncing.
   // TODO(sync): add support for removing types.
   if (initialized())
     AddExperimentalTypes();
 
   // If we are waiting for a configuration change, check here to see
   // if this sync cycle has initialized all of the types we've been
   // waiting for.
   if (pending_download_state_.get()) {
-    scoped_ptr<PendingConfigureDataTypesState> state(
-        pending_download_state_.release());
-    const syncable::ModelTypeSet types_to_add = state->types_to_add;
-    const syncable::ModelTypeSet added_types = state->added_types;
+    const syncable::ModelTypeSet types_to_add =
+        pending_download_state_->types_to_add;
+    const syncable::ModelTypeSet added_types =
+        pending_download_state_->added_types;
     DCHECK(types_to_add.HasAll(added_types));
     const syncable::ModelTypeSet initial_sync_ended =
         snapshot->initial_sync_ended;
     const syncable::ModelTypeSet failed_configuration_types =
         Difference(added_types, initial_sync_ended);
     SDVLOG(1)
         << "Added types: "
         << syncable::ModelTypeSetToString(added_types)
         << ", configured types: "
         << syncable::ModelTypeSetToString(initial_sync_ended)
         << ", failed configuration types: "
         << syncable::ModelTypeSetToString(failed_configuration_types);
+
+    if (!failed_configuration_types.Empty() &&
+        snapshot->retry_scheduled) {
+      // Inform the caller that download failed but we are retrying.
+      if (!pending_download_state_->retry_in_progress) {
+        pending_download_state_->retry_callback.Run();
+        pending_download_state_->retry_in_progress = true;
+      }
+      // Nothing more to do.
+      return;
+    }
+
+    scoped_ptr<PendingConfigureDataTypesState> state(
+        pending_download_state_.release());
     state->ready_task.Run(failed_configuration_types);
+
+    // Syncer did not report an error but did not download everything
+    // we requested either. So abort. The caller of the config will cleanup.
     if (!failed_configuration_types.Empty())
       return;
   }
 
   if (initialized())
     frontend_->OnSyncCycleCompleted();
 }
 
 void SyncBackendHost::FinishConfigureDataTypesOnFrontendLoop() {
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
@@ skipping 114 matching lines @@
   DCHECK(backend.get());
 }
 
 SyncBackendHost::Core::~Core() {
   DCHECK(!sync_manager_.get());
   DCHECK(!sync_loop_);
 }
 
 SyncBackendHost::PendingConfigureDataTypesState::
 PendingConfigureDataTypesState()
-    : reason(sync_api::CONFIGURE_REASON_UNKNOWN) {}
+    : reason(sync_api::CONFIGURE_REASON_UNKNOWN),
+      retry_in_progress(false) {}
 
 SyncBackendHost::PendingConfigureDataTypesState::
 ~PendingConfigureDataTypesState() {}
 
 void SyncBackendHost::Core::OnSyncCycleCompleted(
     const SyncSessionSnapshot* snapshot) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
@@ skipping 305 matching lines @@
   sync_manager_->SaveChanges();
 }
 
 void SyncBackendHost::AddExperimentalTypes() {
   CHECK(initialized());
   syncable::ModelTypeSet to_add;
   if (core_->sync_manager()->ReceivedExperimentalTypes(&to_add))
     frontend_->OnDataTypesChanged(to_add);
 }
 
+void SyncBackendHost::OnNigoriDownloadRetry() {
+  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
+  if (!frontend_)
+    return;
+
+  frontend_->OnSyncConfigureRetry();
+}
+
 void SyncBackendHost::HandleInitializationCompletedOnFrontendLoop(
     const WeakHandle<JsBackend>& js_backend, bool success) {
   DCHECK_NE(NOT_ATTEMPTED, initialization_state_);
   if (!frontend_)
     return;
 
   // We've at least created the sync manager at this point, but if that is all
   // we've done we're just beginning the initialization process.
   if (initialization_state_ == CREATING_SYNC_MANAGER)
     initialization_state_ = NOT_INITIALIZED;
@@ skipping 19 matching lines @@
       initialization_state_ = DOWNLOADING_NIGORI;
       ConfigureDataTypes(
           syncable::ModelTypeSet(),
           syncable::ModelTypeSet(),
           sync_api::CONFIGURE_REASON_NEW_CLIENT,
           // Calls back into this function.
           base::Bind(
               &SyncBackendHost::
                   HandleNigoriConfigurationCompletedOnFrontendLoop,
               weak_ptr_factory_.GetWeakPtr(), js_backend),
+          base::Bind(&SyncBackendHost::OnNigoriDownloadRetry,
+                     weak_ptr_factory_.GetWeakPtr()),
           true);
       break;
     case DOWNLOADING_NIGORI:
       initialization_state_ = REFRESHING_NIGORI;
       // Triggers OnEncryptedTypesChanged() and OnEncryptionComplete()
       // if necessary.
       RefreshNigori(
           base::Bind(
               &SyncBackendHost::
                   HandleInitializationCompletedOnFrontendLoop,
@@ skipping 154 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshNigori,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync