Revert "[Sync] Move DataTypeStatusTable ownership into DataTypeManager."

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 <vector>
 
@@ skipping 944 matching lines @@
 
 void ProfileSyncService::NotifySyncCycleCompleted() {
   FOR_EACH_OBSERVER(ProfileSyncServiceBase::Observer, observers_,
                     OnSyncCycleCompleted());
 }
 
 void ProfileSyncService::ClearStaleErrors() {
   ClearUnrecoverableError();
   last_actionable_error_ = SyncProtocolError();
   // Clear the data type errors as well.
-  if (directory_data_type_manager_.get())
-    directory_data_type_manager_->ResetDataTypeErrors();
-
+  data_type_status_table_.Reset();
 }
 
 void ProfileSyncService::ClearUnrecoverableError() {
   unrecoverable_error_reason_ = ERROR_REASON_UNSET;
   unrecoverable_error_message_.clear();
   unrecoverable_error_location_ = tracked_objects::Location();
 }
 
 void ProfileSyncService::RegisterNewDataType(syncer::ModelType data_type) {
   if (directory_data_type_controllers_.count(data_type) > 0)
@@ skipping 427 matching lines @@
     syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   encrypted_types_ = encrypted_types;
   encrypt_everything_ = encrypt_everything;
   DVLOG(1) << "Encrypted types changed to "
            << syncer::ModelTypeSetToString(encrypted_types_)
            << " (encrypt everything is set to "
            << (encrypt_everything_ ? "true" : "false") << ")";
   DCHECK(encrypted_types_.Has(syncer::PASSWORDS));
 
-  NotifyObservers();
+  // If sessions are encrypted, full history sync is not possible, and
+  // delete directives are unnecessary.
+  if (GetActiveDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES) &&
+      encrypted_types_.Has(syncer::SESSIONS)) {
+    syncer::SyncError error(
+        FROM_HERE,
+        syncer::SyncError::DATATYPE_POLICY_ERROR,
+        "Delete directives not supported with encryption.",
+        syncer::HISTORY_DELETE_DIRECTIVES);
+    DataTypeStatusTable::TypeErrorMap error_map;
+    error_map[error.model_type()] = error;
+    data_type_status_table_.UpdateFailedDataTypes(error_map);
+    ReconfigureDatatypeManager();
+  }
 }
 
 void ProfileSyncService::OnEncryptionComplete() {
   DVLOG(1) << "Encryption complete";
   if (encryption_pending_ && encrypt_everything_) {
     encryption_pending_ = false;
     // This is to nudge the integration tests when encryption is
     // finished.
     NotifyObservers();
   }
@@ skipping 67 matching lines @@
   } else if (error.action == syncer::ROLLBACK_DONE) {
     // Shut down ROLLBACK backend and delete backup DB.
     ShutdownImpl(syncer::DISABLE_SYNC);
     sync_prefs_.ClearFirstSyncTime();
   }
 }
 
 void ProfileSyncService::OnConfigureDone(
     const DataTypeManager::ConfigureResult& result) {
   configure_status_ = result.status;
-  data_type_status_table_ = result.data_type_status_table;
 
   if (backend_mode_ != SYNC) {
     if (configure_status_ == DataTypeManager::OK) {
       StartSyncingWithServer();
 
       // Backup is done after models are associated.
       if (backend_mode_ == BACKUP)
         backup_finished_ = true;
 
       // Asynchronously check whether sync needs to start.
@@ skipping 309 matching lines @@
     bool sync_everything,
     syncer::ModelTypeSet chosen_types) {
   if (!backend_.get() && !HasUnrecoverableError()) {
     NOTREACHED();
     return;
   }
 
   UpdateSelectedTypesHistogram(sync_everything, chosen_types);
   sync_prefs_.SetKeepEverythingSynced(sync_everything);
 
-  if (directory_data_type_manager_.get())
-    directory_data_type_manager_->ResetDataTypeErrors();
+  data_type_status_table_.Reset();
+  if (GetActiveDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES) &&
+      encrypted_types_.Has(syncer::SESSIONS)) {
+    syncer::SyncError error(
+        FROM_HERE,
+        syncer::SyncError::DATATYPE_POLICY_ERROR,
+        "Delete directives not supported with encryption.",
+        syncer::HISTORY_DELETE_DIRECTIVES);
+    DataTypeStatusTable::TypeErrorMap error_map;
+    error_map[error.model_type()] = error;
+    data_type_status_table_.UpdateFailedDataTypes(error_map);
+  }
   ChangePreferredDataTypes(chosen_types);
   AcknowledgeSyncedTypes();
   NotifyObservers();
 }
 
 void ProfileSyncService::ChangePreferredDataTypes(
     syncer::ModelTypeSet preferred_types) {
 
   DVLOG(1) << "ChangePreferredDataTypes invoked";
   const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
@@ skipping 114 matching lines @@
     return;
 
   bool restart = false;
   if (!directory_data_type_manager_) {
     restart = true;
     directory_data_type_manager_.reset(
         factory_->CreateDataTypeManager(debug_info_listener_,
                                         &directory_data_type_controllers_,
                                         this,
                                         backend_.get(),
-                                        this));
+                                        this,
+                                        &data_type_status_table_));
 
     // We create the migrator at the same time.
     migrator_.reset(
         new browser_sync::BackendMigrator(
             profile_->GetDebugName(), GetUserShare(),
             this, directory_data_type_manager_.get(),
             base::Bind(&ProfileSyncService::StartSyncingWithServer,
                        base::Unretained(this))));
   }
 
@@ skipping 780 matching lines @@
                  true));
 }
 
 bool ProfileSyncService::NeedBackup() const {
   return need_backup_;
 }
 
 base::Time ProfileSyncService::GetDeviceBackupTimeForTesting() const {
   return backend_->GetSyncedDeviceTracker()->GetLocalDeviceBackupTime();
 }