[Sync] - Implement isolated model association.

chrome/browser/sync/glue/data_type_manager_impl.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/data_type_manager_impl.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
@@ skipping 62 matching lines @@
       reason == sync_api::CONFIGURE_REASON_RECONFIGURATION) {
     // If we're already configured and the types haven't changed, we can exit
     // out early.
     NotifyStart();
     ConfigureResult result(OK, last_requested_types_);
     NotifyDone(result);
     return;
   }
 
   last_requested_types_ = desired_types;
+  last_nigori_state_ = nigori_state;
   // Only proceed if we're in a steady state or blocked.
   if (state_ != STOPPED && state_ != CONFIGURED && state_ != BLOCKED) {
     DVLOG(1) << "Received configure request while configuration in flight. "
              << "Postponing until current configuration complete.";
     needs_reconfigure_ = true;
     last_configure_reason_ = reason;
-    last_nigori_state_ = nigori_state;
     return;
   }
 
-  model_association_manager_.Initialize(desired_types);
   Restart(reason, nigori_state);
 }
 
 void DataTypeManagerImpl::Restart(
     sync_api::ConfigureReason reason,
     BackendDataTypeConfigurer::NigoriState nigori_state) {
   DVLOG(1) << "Restarting...";
+  model_association_manager_.Initialize(last_requested_types_);
   last_restart_time_ = base::Time::Now();
 
   DCHECK(state_ == STOPPED || state_ == CONFIGURED || state_ == BLOCKED);
 
   // Starting from a "steady state" (stopped or configured) state
   // should send a start notification.
   if (state_ == STOPPED || state_ == CONFIGURED)
     NotifyStart();
 
   model_association_manager_.StopDisabledTypes();
@@ skipping 92 matching lines @@
     return;
   }
 
   state_ = CONFIGURING;
   model_association_manager_.StartAssociationAsync();
 }
 
 void DataTypeManagerImpl::OnModelAssociationDone(
     const DataTypeManager::ConfigureResult& result) {
   if (result.status == ABORTED || result.status == UNRECOVERABLE_ERROR) {
-    Abort(result.status, result.errors.size() >= 1 ?
-                         result.errors.front() :
+    Abort(result.status, result.failed_data_types.size() >= 1 ?
+                         result.failed_data_types.front() :
                          SyncError());
-
     return;
   }
 
   if (ProcessReconfigure()) {
     return;
   }
 
   if (result.status == CONFIGURE_BLOCKED) {
     failed_datatypes_info_.insert(failed_datatypes_info_.end(),
-                                  result.errors.begin(),
-                                  result.errors.end());
+                                  result.failed_data_types.begin(),
+                                  result.failed_data_types.end());
     SetBlockedAndNotify();
     return;
   }
 
   DCHECK(result.status == PARTIAL_SUCCESS || result.status == OK);
   state_ = CONFIGURED;
   failed_datatypes_info_.insert(failed_datatypes_info_.end(),
-                                result.errors.begin(),
-                                result.errors.end());
+                                result.failed_data_types.begin(),
+                                result.failed_data_types.end());
   ConfigureResult configure_result(result.status,
                                    result.requested_types,
-                                   failed_datatypes_info_);
+                                   failed_datatypes_info_,
+                                   result.waiting_to_start);
   NotifyDone(configure_result);
   failed_datatypes_info_.clear();
 }
 
+void DataTypeManagerImpl::OnTypesLoaded() {
+  if (state_ != CONFIGURED) {
+    // Ignore this. either we just started another configuration or
+    // we are in some sort of error.
+    return;
+  }
+
+  Restart(sync_api::CONFIGURE_REASON_RECONFIGURATION,
+          last_nigori_state_);
+}
+
 
 void DataTypeManagerImpl::Stop() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (state_ == STOPPED)
     return;
 
   // If we are currently configuring, then the current type is in a
   // partially started state.  Abort the startup of the current type,
   // which will synchronously invoke the start callback.
   if (state_ == CONFIGURING) {
@@ skipping 27 matching lines @@
 
 void DataTypeManagerImpl::Abort(ConfigureStatus status,
                                 const SyncError& error) {
   DCHECK_NE(OK, status);
   FinishStop();
   std::list<SyncError> error_list;
   if (error.IsSet())
     error_list.push_back(error);
   ConfigureResult result(status,
                          last_requested_types_,
-                         error_list);
+                         error_list,
+                         syncable::ModelTypeSet());
   NotifyDone(result);
 }
 
 void DataTypeManagerImpl::NotifyStart() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SYNC_CONFIGURE_START,
       content::Source<DataTypeManager>(this),
       content::NotificationService::NoDetails());
 }
 
@@ skipping 47 matching lines @@
       content::Source<DataTypeManager>(this),
       content::NotificationService::NoDetails());
 }
 
 void DataTypeManagerImpl::AddToConfigureTime() {
   DCHECK(!last_restart_time_.is_null());
   configure_time_delta_ += (base::Time::Now() - last_restart_time_);
 }
 
 }  // namespace browser_sync