[Sync] Handle errors during first sync gracefully.

chrome/browser/sync/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/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 336 matching lines @@
   return !Intersection(preferred_types, encrypted_types).Empty();
 }
 
 void ProfileSyncService::OnSyncConfigureDone(
     DataTypeManager::ConfigureResult result) {
   if (failed_datatypes_handler_.UpdateFailedDatatypes(result)) {
     ReconfigureDatatypeManager();
   }
 }
 
+void ProfileSyncService::OnSyncConfigureRetry() {
+  if (wizard_.IsVisible()) {

[Andrew T Wilson (Slow), 2012/01/27 00:19:03]

Instead of forwarding this to the SyncSetupWizard (see my comment in
sync_setup_flow.cc) I think we should do this:

// If we're not doing autostart, then abort sync setup if our configuration
fails.
if (!auto_start_enabled_)
  OnUnrecoverableError(....);

[lipalani1, 2012/01/27 02:54:29]

Done.

+    wizard_.Step(SyncSetupWizard::CONFIGURE_RETRY);

[Andrew T Wilson (Slow), 2012/01/27 00:19:03]

Soon, SyncSetupWizard will be going away. Instead, the UI will register itself
as an Observer, and will need to query for things like "retry status" via APIs,
rather than relying on the ProfileSyncService directly modifying state in
SyncSetupWizard. This will also allow things like Clank to provide feedback to
the user without actually having to use SyncSetupWizard.

So, can we track and expose this retry state through a member variable and also
notify observers when the status of that variable changes?

[lipalani1, 2012/01/27 02:54:29]

Done.

+  }
+
+  // If the wizard is not visible nothing more to do. We just wait until
+  // configure succeeds.
+}
+
+
 void ProfileSyncService::StartUp() {
   // Don't start up multiple times.
   if (backend_.get()) {
     DVLOG(1) << "Skipping bringing up backend host.";
     return;
   }
 
   DCHECK(AreCredentialsAvailable());
 
   last_synced_time_ = sync_prefs_.GetLastSyncedTime();
@@ skipping 961 matching lines @@
       NotifyObservers();
       // TODO(sync): Maybe toast?
       break;
     }
     case chrome::NOTIFICATION_SYNC_CONFIGURE_DONE: {
       DataTypeManager::ConfigureResult* result =
           content::Details<DataTypeManager::ConfigureResult>(details).ptr();
 
       DataTypeManager::ConfigureStatus status = result->status;
       DVLOG(1) << "PSS SYNC_CONFIGURE_DONE called with status: " << status;
+
+      // The possible status values:
+      //    ABORT - Configuration was aborted. This is not an error, if
+      //            initiated by user..
+      //    RETRY - Configure failed but we are retrying.
+      //    OK - Everything succeeded.
+      //    PARTIAL_SUCCESS - Some datatypes failed to start.
+      //    Everything else is an UnrecoverableError. So treat it as such.
+
+      // First handle the abort case.
       if (status == DataTypeManager::ABORTED &&
           expect_sync_configuration_aborted_) {
         DVLOG(0) << "ProfileSyncService::Observe Sync Configure aborted";
         expect_sync_configuration_aborted_ = false;
         return;
       }
+
+      // Handle retry case.
+      if (status == DataTypeManager::RETRY) {
+        OnSyncConfigureRetry();
+        return;
+      }
+
+      // Hanlde unrecoverable error.

[Andrew T Wilson (Slow), 2012/01/27 00:19:03]

nit: Hanlde->Handle

[lipalani1, 2012/01/27 02:54:29]

Done.

       if (status != DataTypeManager::OK &&
           status != DataTypeManager::PARTIAL_SUCCESS) {
         // Something catastrophic had happened. We should only have one
         // error representing it.
         DCHECK(result->errors.size() == 1);
         SyncError error = result->errors.front();
         DCHECK(error.IsSet());
         std::string message =
           "Sync configuration failed with status " +
           DataTypeManager::ConfigureStatusToString(status) +
           " during " + syncable::ModelTypeToString(error.type()) +
           ": " + error.message();
         LOG(ERROR) << "ProfileSyncService error: "
                    << message;
         // TODO: Don't
         OnUnrecoverableError(error.location(), message);
         return;
       }
 
+      // Now handle partial success and full success.
       MessageLoop::current()->PostTask(FROM_HERE,
           base::Bind(&ProfileSyncService::OnSyncConfigureDone,
                      weak_factory_.GetWeakPtr(), *result));
 
       // We should never get in a state where we have no encrypted datatypes
       // enabled, and yet we still think we require a passphrase for decryption.
       DCHECK(!(IsPassphraseRequiredForDecryption() &&
                !IsEncryptedDatatypeEnabled()));
 
       // This must be done before we start syncing with the server to avoid
@@ skipping 187 matching lines @@
              << "Unrecoverable error.";
   } else {
     DVLOG(0) << "ConfigureDataTypeManager not invoked because backend is not "
              << "initialized";
   }
 }
 
 const FailedDatatypesHandler& ProfileSyncService::failed_datatypes_handler() {
   return failed_datatypes_handler_;
 }