[Sync] Refactor sync datatype error handling.

chrome/browser/sync/backend_migrator.cc

 // Copyright (c) 2011 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/backend_migrator.h"
 
 #include <algorithm>
 
 #include "base/string_number_conversions.h"
 #include "chrome/browser/sync/profile_sync_service.h"
@@ skipping 103 matching lines @@
   manager_->Configure(full_set, sync_api::CONFIGURE_REASON_MIGRATION);
 }
 
 void BackendMigrator::Observe(int type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_SYNC_CONFIGURE_DONE, type);
   if (state_ == IDLE)
     return;
 
-  DataTypeManager::ConfigureResultWithErrorLocation* result =
-      Details<DataTypeManager::ConfigureResultWithErrorLocation>(
-          details).ptr();
+  const DataTypeManager::ConfigureResult* result =
+      Details<DataTypeManager::ConfigureResult>(details).ptr();
 
   ModelTypeSet intersection;
   std::set_intersection(result->requested_types.begin(),
       result->requested_types.end(), to_migrate_.begin(), to_migrate_.end(),
       std::inserter(intersection, intersection.end()));
 
   // The intersection check is to determine if our disable request was
   // interrupted by a user changing preferred types.  May still need to purge.
   // It's pretty wild if we're in WAITING_FOR_PURGE here, because it would mean
   // that after our disable-config finished but before the purge, another config
   // was posted externally _and completed_, which means somehow the nudge to
   // purge was dropped, yet nudges are reliable.
   if (state_ == WAITING_TO_START || state_ == WAITING_FOR_PURGE ||
       (state_ == DISABLING_TYPES && !intersection.empty())) {
     state_ = WAITING_TO_START;
     restart_migration_ = false;
     VLOG(1) << "BackendMigrator::Observe posting MigrateTypes.";
     if (!BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         method_factory_.NewRunnableMethod(&BackendMigrator::MigrateTypes,
                                           to_migrate_))) {
       // Unittests need this.
       // TODO(tim): Clean this up.
       MigrateTypes(to_migrate_);
     }
     return;
   }
 
-  if (result->result != DataTypeManager::OK) {
+  if (result->status != DataTypeManager::OK) {
     // If this fails, and we're disabling types, a type may or may not be
     // disabled until the user restarts the browser.  If this wasn't an abort,
     // any failure will be reported as an unrecoverable error to the UI. If it
     // was an abort, then typically things are shutting down anyway. There isn't
     // much we can do in any case besides wait until a restart to try again.
     // The server will send down MIGRATION_DONE again for types needing
     // migration as the type will still be enabled on restart.
     LOG(WARNING) << "Unable to migrate, configuration failed!";
     state_ = IDLE;
     to_migrate_.clear();
@@ skipping 13 matching lines @@
     VLOG(1) << "BackendMigrator: Migration complete for: " << ss.str();
     to_migrate_.clear();
   }
 }
 
 BackendMigrator::State BackendMigrator::state() const {
   return state_;
 }
 
 };  // namespace browser_sync