[Sync] Trigger unapply + getupdates for persistence errors

chrome/browser/sync/glue/model_association_manager.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/glue/model_association_manager.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/debug/trace_event.h"
@@ skipping 128 matching lines @@
   // TODO(tim): Bug 134550.  CHECKing to ensure no reentrancy on dev channel.
   // Remove this.
   CHECK_EQ(state_, IDLE);
   needs_start_.clear();
   needs_stop_.clear();
   failed_data_types_info_.clear();
   associating_types_.Clear();
   needs_crypto_types_.Clear();
   state_ = INITIALIZED_TO_CONFIGURE;
 
-  DVLOG(1) << "ModelAssociationManager: Initializing";
+  DVLOG(1) << "ModelAssociationManager: Initializing for "
+           << syncer::ModelTypeSetToString(desired_types);
 
   // Stop the types that are still loading from the previous configuration.
   // If they are enabled we will start them here once again.
   for (std::vector<DataTypeController*>::const_iterator it =
            pending_model_load_.begin();
        it != pending_model_load_.end();
        ++it) {
     DVLOG(1) << "ModelAssociationManager: Stopping "
              << (*it)->name()
              << " before initialization";
@@ skipping 46 matching lines @@
   state_ = IDLE;
   DVLOG(1) << "ModelAssociationManager: Reseting for reconfiguration";
   needs_start_.clear();
   needs_stop_.clear();
   associating_types_.Clear();
   failed_data_types_info_.clear();
   needs_crypto_types_.Clear();
 }
 
 void ModelAssociationManager::StopDisabledTypes() {
-  DCHECK_EQ(state_, INITIALIZED_TO_CONFIGURE);
   DVLOG(1) << "ModelAssociationManager: Stopping disabled types.";
   // Stop requested data types.
   for (size_t i = 0; i < needs_stop_.size(); ++i) {
     DVLOG(1) << "ModelAssociationManager: Stopping " << needs_stop_[i]->name();
     needs_stop_[i]->Stop();
   }
   needs_stop_.clear();
 }
 
 void ModelAssociationManager::Stop() {
   bool need_to_call_model_association_done = false;
   DVLOG(1) << "ModelAssociationManager: Stopping MAM";
   if (state_ == CONFIGURING) {
-    DVLOG(1) << "ModelAssociationManager: In the middle of configuratio while"
+    DVLOG(1) << "ModelAssociationManager: In the middle of configuration while"
              << " stopping";
     state_ = ABORTED;
     DCHECK(currently_associating_ != NULL ||
            needs_start_.size() > 0 ||
            pending_model_load_.size() > 0 ||
            waiting_to_associate_.size() > 0);
 
     if (currently_associating_) {
       TRACE_EVENT_END0("sync", "ModelAssociation");
       DVLOG(1) << "ModelAssociationManager: stopping "
@@ skipping 183 matching lines @@
                  base::TimeDelta::FromSeconds(kDataTypeLoadWaitTimeInSeconds),
                  this,
                  &ModelAssociationManager::LoadModelForNextType);
     dtc->LoadModels(base::Bind(
         &ModelAssociationManager::ModelLoadCallback,
         weak_ptr_factory_.GetWeakPtr()));
 
     return;
   }
 
-  DVLOG(1) << "ModelAssociationManager: All types have models loaded."
+  DVLOG(1) << "ModelAssociationManager: All types have models loaded. "
           << "Moving on to StartAssociatingNextType.";
 
   // If all controllers have their |LoadModels| invoked then pass onto
   // |StartAssociatingNextType|.
   StartAssociatingNextType();
 }
 
 void ModelAssociationManager::ModelLoadCallback(
     syncer::ModelType type, syncer::SyncError error) {
   DVLOG(1) << "ModelAssociationManager: ModelLoadCallback for "
@@ skipping 34 matching lines @@
           TypeStartCallback(DataTypeController::ASSOCIATION_FAILED,
                             local_merge_result,
                             syncer::SyncMergeResult(type));
        }
        return;
       }
     }
     NOTREACHED();
     return;
   } else if (state_ == IDLE) {
-    DVLOG(1) << "ModelAssociationManager: Models loaded after configure cycle"
+    DVLOG(1) << "ModelAssociationManager: Models loaded after configure cycle. "
             << "Informing DTM";
     // This datatype finished loading after the deadline imposed by the
     // originating configuration cycle. Inform the DataTypeManager that the
     // type has loaded, so that association may begin.
     result_processor_->OnTypesLoaded();
   } else {
     // If we're not IDLE or CONFIGURING, we're being invoked as part of an abort
     // process (possibly a reconfiguration, or disabling of a broken data type).
     DVLOG(1) << "ModelAssociationManager: ModelLoadCallback occurred while "
              << "not IDLE or CONFIGURING. Doing nothing.";
@@ skipping 15 matching lines @@
     DataTypeController* dtc = waiting_to_associate_[0];
     waiting_to_associate_.erase(waiting_to_associate_.begin());
     currently_associating_ = dtc;
     current_type_association_start_time_ = base::Time::Now();
     dtc->StartAssociating(base::Bind(
         &ModelAssociationManager::TypeStartCallback,
         weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
-  // We are done with this cycle of association.
+  // We are done with this cycle of association. Stop any failed types now.
+  needs_stop_.clear();
+  for (DataTypeController::TypeMap::const_iterator it = controllers_->begin();
+       it != controllers_->end(); ++it) {
+    DataTypeController* dtc = (*it).second.get();
+    if (failed_data_types_info_.count(dtc->type()) > 0 &&
+        dtc->state() != DataTypeController::NOT_RUNNING) {
+      needs_stop_.push_back(dtc);
+      DVLOG(1) << "ModelTypeToString: Will stop " << dtc->name();
+    }
+  }
+  StopDisabledTypes();
+
   state_ = IDLE;
 
   DataTypeManager::ConfigureStatus configure_status = DataTypeManager::OK;
 
   if (!failed_data_types_info_.empty() ||
       !GetTypesWaitingToLoad().Empty() ||
       !needs_crypto_types_.Empty()) {
     // We have not configured all types that we have been asked to configure.
     // Either we have failed types or types that have not completed loading
     // yet.
@@ skipping 20 matching lines @@
   }
   return result;
 }
 
 base::OneShotTimer<ModelAssociationManager>*
     ModelAssociationManager::GetTimerForTesting() {
   return &timer_;
 }
 
 }  // namespace browser_sync