Merge 144583 - sync: fix reentrancy crash in ModelAssociationManager

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 <algorithm>
 #include <functional>
 
 #include "base/debug/trace_event.h"
 
 #include "base/logging.h"
@@ skipping 83 matching lines @@
   // Build a ModelType -> order map for sorting.
   for (int i = 0; i < static_cast<int>(arraysize(kStartOrder)); i++)
     start_order_[kStartOrder[i]] = i;
 }
 
 ModelAssociationManager::~ModelAssociationManager() {
 }
 
 void ModelAssociationManager::Initialize(
     syncable::ModelTypeSet desired_types) {
-  DCHECK_EQ(state_, IDLE);
   needs_start_.clear();
   needs_stop_.clear();
   failed_datatypes_info_.clear();
   desired_types_ = desired_types;
-  state_ = INITIAILIZED_TO_CONFIGURE;
+  state_ = INITIALIZED_TO_CONFIGURE;
 
   DVLOG(1) << "ModelAssociationManager: Initializing";
 
   // 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 "
@@ skipping 27 matching lines @@
       DVLOG(1) << "ModelTypeToString: Will stop " << dtc->name();
     }
   }
   // Sort these according to kStartOrder.
   std::sort(needs_stop_.begin(),
             needs_stop_.end(),
             SortComparator(&start_order_));
 }
 
 void ModelAssociationManager::StartAssociationAsync() {
-  DCHECK_EQ(state_, INITIAILIZED_TO_CONFIGURE);
+  DCHECK_EQ(state_, INITIALIZED_TO_CONFIGURE);
   state_ = CONFIGURING;
   DVLOG(1) << "ModelAssociationManager: Going to start model association";
   LoadModelForNextType();
 }
 
 void ModelAssociationManager::ResetForReconfiguration() {
-  DCHECK_EQ(state_, INITIAILIZED_TO_CONFIGURE);
+  DCHECK_EQ(state_, INITIALIZED_TO_CONFIGURE);
   state_ = IDLE;
   DVLOG(1) << "ModelAssociationManager: Reseting for reconfiguration";
   needs_start_.clear();
   needs_stop_.clear();
   failed_datatypes_info_.clear();
 }
 
 void ModelAssociationManager::StopDisabledTypes() {
-  DCHECK_EQ(state_, INITIAILIZED_TO_CONFIGURE);
+  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() {
@@ skipping 20 matching lines @@
 
     DCHECK_EQ(IDLE, state_);
 
     // We are in the midle of model association. We need to inform the caller
     // so the caller can send notificationst to PSS layer.
     need_to_call_model_association_done = true;
   }
 
   // Now continue stopping any types that have already started.
   DCHECK(state_ == IDLE ||
-         state_ == INITIAILIZED_TO_CONFIGURE);
+         state_ == INITIALIZED_TO_CONFIGURE);
   for (DataTypeController::TypeMap::const_iterator it = controllers_->begin();
        it != controllers_->end(); ++it) {
     DataTypeController* dtc = (*it).second;
     if (dtc->state() != DataTypeController::NOT_RUNNING &&
         dtc->state() != DataTypeController::STOPPING) {
       dtc->Stop();
       DVLOG(1) << "ModelAssociationManager: Stopped " << dtc->name();
     }
   }
 
@@ skipping 184 matching lines @@
          // Treat it like a regular error.
          AppendToFailedDatatypesAndLogError(
              DataTypeController::ASSOCIATION_FAILED,
              error);
        }
        return;
       }
     }
     NOTREACHED();
     return;
-  } else {
+  } else if (state_ == IDLE) {
     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.";
   }
 
 }
 
 void ModelAssociationManager::StartAssociatingNextType() {
   DCHECK_EQ(state_, CONFIGURING);
   DCHECK_EQ(currently_associating_, static_cast<DataTypeController*>(NULL));
 
   DVLOG(1) << "ModelAssociationManager: StartAssociatingNextType";
   if (!waiting_to_associate_.empty()) {
@@ skipping 59 matching lines @@
   }
   return result;
 }
 
 base::OneShotTimer<ModelAssociationManager>*
     ModelAssociationManager::GetTimerForTesting() {
   return &timer_;
 }
 
 }  // namespace browser_sync
-