[Sync] Rename FailedDataTypesHandler -> DataTypeStatusTable

Simple rename patch, in preparation for making the DataTypeStatusTable
copy-able and having it track more than just errors.

BUG=368834

Review URL: https://codereview.chromium.org/513543004

Cr-Commit-Position: refs/heads/master@{#292453}

6 files changed, 65 insertions, 65 deletions

diff --git a/components/sync_driver/BUILD.gn b/components/sync_driver/BUILD.gn
index 0906258..78d284b 100644
--- a/components/sync_driver/BUILD.gn
+++ b/components/sync_driver/BUILD.gn
@@ -18,8 +18,8 @@ static_library("sync_driver") {
     "data_type_manager_impl.cc",
     "data_type_manager_impl.h",
     "data_type_manager_observer.h",
-    "failed_data_types_handler.cc",
-    "failed_data_types_handler.h",
+    "data_type_status_table.cc",
+    "data_type_status_table.h",
     "generic_change_processor.cc",
     "generic_change_processor.h",
     "generic_change_processor_factory.cc",
diff --git a/components/sync_driver/data_type_manager_impl.cc b/components/sync_driver/data_type_manager_impl.cc
index 936a745..856722e 100644
--- a/components/sync_driver/data_type_manager_impl.cc
+++ b/components/sync_driver/data_type_manager_impl.cc
@@ -18,16 +18,16 @@
 #include "components/sync_driver/data_type_controller.h"
 #include "components/sync_driver/data_type_encryption_handler.h"
 #include "components/sync_driver/data_type_manager_observer.h"
-#include "components/sync_driver/failed_data_types_handler.h"
+#include "components/sync_driver/data_type_status_table.h"
 #include "sync/internal_api/public/data_type_debug_info_listener.h"
 
 namespace sync_driver {
 
 namespace {
 
-FailedDataTypesHandler::TypeErrorMap
+DataTypeStatusTable::TypeErrorMap
 GenerateCryptoErrorsForTypes(syncer::ModelTypeSet encrypted_types) {
-  FailedDataTypesHandler::TypeErrorMap crypto_errors;
+  DataTypeStatusTable::TypeErrorMap crypto_errors;
   for (syncer::ModelTypeSet::Iterator iter = encrypted_types.First();
          iter.Good(); iter.Inc()) {
     crypto_errors[iter.Get()] = syncer::SyncError(
@@ -52,7 +52,7 @@ DataTypeManagerImpl::DataTypeManagerImpl(
     const DataTypeEncryptionHandler* encryption_handler,
     BackendDataTypeConfigurer* configurer,
     DataTypeManagerObserver* observer,
-    FailedDataTypesHandler* failed_data_types_handler)
+    DataTypeStatusTable* data_type_status_table)
     : configurer_(configurer),
       controllers_(controllers),
       state_(DataTypeManager::STOPPED),
@@ -61,11 +61,11 @@ DataTypeManagerImpl::DataTypeManagerImpl(
       debug_info_listener_(debug_info_listener),
       model_association_manager_(controllers, this),
       observer_(observer),
-      failed_data_types_handler_(failed_data_types_handler),
+      data_type_status_table_(data_type_status_table),
       encryption_handler_(encryption_handler),
       unrecoverable_error_method_(unrecoverable_error_method),
       weak_ptr_factory_(this) {
-  DCHECK(failed_data_types_handler_);
+  DCHECK(data_type_status_table_);
   DCHECK(configurer_);
   DCHECK(observer_);
 }
@@ -89,7 +89,7 @@ void DataTypeManagerImpl::Configure(syncer::ModelTypeSet desired_types,
         iter != controllers_->end()) {
       if (iter != controllers_->end()) {
         if (!iter->second->ReadyForStart() &&
-            !failed_data_types_handler_->GetUnreadyErrorTypes().Has(
+            !data_type_status_table_->GetUnreadyErrorTypes().Has(
                 type.Get())) {
           // Add the type to the unready types set to prevent purging it. It's
           // up to the datatype controller to, if necessary, explicitly
@@ -100,9 +100,9 @@ void DataTypeManagerImpl::Configure(syncer::ModelTypeSet desired_types,
                                   type.Get());
           std::map<syncer::ModelType, syncer::SyncError> errors;
           errors[type.Get()] = error;
-          failed_data_types_handler_->UpdateFailedDataTypes(errors);
+          data_type_status_table_->UpdateFailedDataTypes(errors);
         } else if (iter->second->ReadyForStart()) {
-          failed_data_types_handler_->ResetUnreadyErrorFor(type.Get());
+          data_type_status_table_->ResetUnreadyErrorFor(type.Get());
         }
       }
       filtered_desired_types.Put(type.Get());
@@ -115,8 +115,8 @@ void DataTypeManagerImpl::ReenableType(syncer::ModelType type) {
   // TODO(zea): move the "should we reconfigure" logic into the datatype handler
   // itself.
   // Only reconfigure if the type actually had a data type or unready error.
-  if (!failed_data_types_handler_->ResetDataTypeErrorFor(type) &&
-      !failed_data_types_handler_->ResetUnreadyErrorFor(type)) {
+  if (!data_type_status_table_->ResetDataTypeErrorFor(type) &&
+      !data_type_status_table_->ResetUnreadyErrorFor(type)) {
     return;
   }
 
@@ -177,18 +177,18 @@ DataTypeManagerImpl::BuildDataTypeConfigStateMap(
   // 4. Set non-enabled user types as DISABLED.
   // 5. Set the fatal, crypto, and unready types to their respective states.
   syncer::ModelTypeSet error_types =
-      failed_data_types_handler_->GetFailedTypes();
+      data_type_status_table_->GetFailedTypes();
   syncer::ModelTypeSet fatal_types =
-      failed_data_types_handler_->GetFatalErrorTypes();
+      data_type_status_table_->GetFatalErrorTypes();
   syncer::ModelTypeSet crypto_types =
-      failed_data_types_handler_->GetCryptoErrorTypes();
+      data_type_status_table_->GetCryptoErrorTypes();
   syncer::ModelTypeSet unready_types=
-      failed_data_types_handler_->GetUnreadyErrorTypes();
+      data_type_status_table_->GetUnreadyErrorTypes();
 
   // Types with persistence errors are only purged/resynced when they're
   // actively being configured.
   syncer::ModelTypeSet persistence_types =
-      failed_data_types_handler_->GetPersistenceErrorTypes();
+      data_type_status_table_->GetPersistenceErrorTypes();
   persistence_types.RetainAll(types_being_configured);
 
   // Types with unready errors do not count as unready if they've been disabled.
@@ -240,16 +240,16 @@ void DataTypeManagerImpl::Restart(syncer::ConfigureReason reason) {
         encryption_handler_->GetEncryptedDataTypes();
     encrypted_types.RetainAll(last_requested_types_);
     encrypted_types.RemoveAll(
-        failed_data_types_handler_->GetCryptoErrorTypes());
-    FailedDataTypesHandler::TypeErrorMap crypto_errors =
+        data_type_status_table_->GetCryptoErrorTypes());
+    DataTypeStatusTable::TypeErrorMap crypto_errors =
         GenerateCryptoErrorsForTypes(encrypted_types);
-    failed_data_types_handler_->UpdateFailedDataTypes(crypto_errors);
+    data_type_status_table_->UpdateFailedDataTypes(crypto_errors);
   } else {
-    failed_data_types_handler_->ResetCryptoErrors();
+    data_type_status_table_->ResetCryptoErrors();
   }
 
   syncer::ModelTypeSet failed_types =
-      failed_data_types_handler_->GetFailedTypes();
+      data_type_status_table_->GetFailedTypes();
   syncer::ModelTypeSet enabled_types =
       syncer::Difference(last_requested_types_, failed_types);
 
@@ -353,7 +353,7 @@ void DataTypeManagerImpl::DownloadReady(
 
   // Persistence errors are reset after each backend configuration attempt
   // during which they would have been purged.
-  failed_data_types_handler_->ResetPersistenceErrorsFrom(types_to_download);
+  data_type_status_table_->ResetPersistenceErrorsFrom(types_to_download);
 
   // Ignore |failed_configuration_types| if we need to reconfigure
   // anyway.
@@ -366,7 +366,7 @@ void DataTypeManagerImpl::DownloadReady(
   if (!failed_configuration_types.Empty()) {
     if (!unrecoverable_error_method_.is_null())
       unrecoverable_error_method_.Run();
-    FailedDataTypesHandler::TypeErrorMap errors;
+    DataTypeStatusTable::TypeErrorMap errors;
     for (syncer::ModelTypeSet::Iterator iter =
              failed_configuration_types.First(); iter.Good(); iter.Inc()) {
       syncer::SyncError error(
@@ -376,7 +376,7 @@ void DataTypeManagerImpl::DownloadReady(
           iter.Get());
       errors[iter.Get()] = error;
     }
-    failed_data_types_handler_->UpdateFailedDataTypes(errors);
+    data_type_status_table_->UpdateFailedDataTypes(errors);
     Abort(UNRECOVERABLE_ERROR);
     return;
   }
@@ -429,9 +429,9 @@ void DataTypeManagerImpl::OnSingleDataTypeWillStop(
     const syncer::SyncError& error) {
   configurer_->DeactivateDataType(type);
   if (error.IsSet()) {
-    FailedDataTypesHandler::TypeErrorMap failed_types;
+    DataTypeStatusTable::TypeErrorMap failed_types;
     failed_types[type] = error;
-    failed_data_types_handler_->UpdateFailedDataTypes(
+    data_type_status_table_->UpdateFailedDataTypes(
             failed_types);
 
     // Unrecoverable errors will shut down the entire backend, so no need to
diff --git a/components/sync_driver/data_type_manager_impl.h b/components/sync_driver/data_type_manager_impl.h
index 8d42ea8..abd7fbc 100644
--- a/components/sync_driver/data_type_manager_impl.h
+++ b/components/sync_driver/data_type_manager_impl.h
@@ -30,7 +30,7 @@ namespace sync_driver {
 class DataTypeController;
 class DataTypeEncryptionHandler;
 class DataTypeManagerObserver;
-class FailedDataTypesHandler;
+class DataTypeStatusTable;
 
 // List of data types grouped by priority and ordered from high priority to
 // low priority.
@@ -47,7 +47,7 @@ class DataTypeManagerImpl : public DataTypeManager,
       const DataTypeEncryptionHandler* encryption_handler,
       BackendDataTypeConfigurer* configurer,
       DataTypeManagerObserver* observer,
-      FailedDataTypesHandler* failed_data_types_handler);
+      DataTypeStatusTable* data_type_status_table);
   virtual ~DataTypeManagerImpl();
 
   // DataTypeManager interface.
@@ -163,7 +163,7 @@ class DataTypeManagerImpl : public DataTypeManager,
 
   // For querying failed data types (having unrecoverable error) when
   // configuring backend.
-  FailedDataTypesHandler* failed_data_types_handler_;
+  DataTypeStatusTable* data_type_status_table_;
 
   // Types waiting to be downloaded.
   TypeSetPriorityList download_types_queue_;
diff --git a/components/sync_driver/data_type_manager_impl_unittest.cc b/components/sync_driver/data_type_manager_impl_unittest.cc
index 80edbe0..054e267 100644
--- a/components/sync_driver/data_type_manager_impl_unittest.cc
+++ b/components/sync_driver/data_type_manager_impl_unittest.cc
@@ -10,7 +10,7 @@
 #include "components/sync_driver/data_type_controller.h"
 #include "components/sync_driver/data_type_encryption_handler.h"
 #include "components/sync_driver/data_type_manager_observer.h"
-#include "components/sync_driver/failed_data_types_handler.h"
+#include "components/sync_driver/data_type_status_table.h"
 #include "components/sync_driver/fake_data_type_controller.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/configure_reason.h"
@@ -152,14 +152,14 @@ class TestDataTypeManager : public DataTypeManagerImpl {
       const DataTypeController::TypeMap* controllers,
       const DataTypeEncryptionHandler* encryption_handler,
       DataTypeManagerObserver* observer,
-      FailedDataTypesHandler* failed_data_types_handler)
+      DataTypeStatusTable* data_type_status_table)
       : DataTypeManagerImpl(base::Closure(),
                             debug_info_listener,
                             controllers,
                             encryption_handler,
                             configurer,
                             observer,
-                            failed_data_types_handler),
+                            data_type_status_table),
         custom_priority_types_(syncer::ControlTypes()) {}
 
   void set_priority_types(const syncer::ModelTypeSet& priority_types) {
@@ -203,7 +203,7 @@ class SyncDataTypeManagerImplTest : public testing::Test {
            &controllers_,
            &encryption_handler_,
            &observer_,
-           &failed_data_types_handler_));
+           &data_type_status_table_));
   }
 
   void SetConfigureStartExpectation() {
@@ -262,7 +262,7 @@ class SyncDataTypeManagerImplTest : public testing::Test {
   FakeBackendDataTypeConfigurer configurer_;
   DataTypeManagerObserverMock observer_;
   scoped_ptr<TestDataTypeManager> dtm_;
-  FailedDataTypesHandler failed_data_types_handler_;
+  DataTypeStatusTable data_type_status_table_;
   FakeDataTypeEncryptionHandler encryption_handler_;
 };
 
@@ -1161,7 +1161,7 @@ TEST_F(SyncDataTypeManagerImplTest, ReenableAfterDataTypeError) {
                           syncer::BOOKMARKS);
   std::map<syncer::ModelType, syncer::SyncError> errors;
   errors[syncer::BOOKMARKS] = error;
-  failed_data_types_handler_.UpdateFailedDataTypes(errors);
+  data_type_status_table_.UpdateFailedDataTypes(errors);
 
   AddController(PREFERENCES);  // Will succeed.
   AddController(BOOKMARKS);    // Will be disabled due to datatype error.
diff --git a/components/sync_driver/failed_data_types_handler.cc b/components/sync_driver/data_type_status_table.cc
index 8ee9c1d..d96b3b1 100644
--- a/components/sync_driver/failed_data_types_handler.cc
+++ b/components/sync_driver/data_type_status_table.cc
@@ -3,16 +3,16 @@
 // found in the LICENSE file.
 
 #include "components/sync_driver/data_type_manager.h"
-#include "components/sync_driver/failed_data_types_handler.h"
+#include "components/sync_driver/data_type_status_table.h"
 
 namespace sync_driver {
 
 namespace {
 
 syncer::ModelTypeSet GetTypesFromErrorMap(
-    const FailedDataTypesHandler::TypeErrorMap& errors) {
+    const DataTypeStatusTable::TypeErrorMap& errors) {
   syncer::ModelTypeSet result;
-  for (FailedDataTypesHandler::TypeErrorMap::const_iterator it = errors.begin();
+  for (DataTypeStatusTable::TypeErrorMap::const_iterator it = errors.begin();
        it != errors.end(); ++it) {
     DCHECK(!result.Has(it->first));
     result.Put(it->first);
@@ -22,13 +22,13 @@ syncer::ModelTypeSet GetTypesFromErrorMap(
 
 }  // namespace
 
-FailedDataTypesHandler::FailedDataTypesHandler() {
+DataTypeStatusTable::DataTypeStatusTable() {
 }
 
-FailedDataTypesHandler::~FailedDataTypesHandler() {
+DataTypeStatusTable::~DataTypeStatusTable() {
 }
 
-bool FailedDataTypesHandler::UpdateFailedDataTypes(const TypeErrorMap& errors) {
+bool DataTypeStatusTable::UpdateFailedDataTypes(const TypeErrorMap& errors) {
   if (errors.empty())
     return false;
 
@@ -62,7 +62,7 @@ bool FailedDataTypesHandler::UpdateFailedDataTypes(const TypeErrorMap& errors) {
   return true;
 }
 
-void FailedDataTypesHandler::Reset() {
+void DataTypeStatusTable::Reset() {
   unrecoverable_errors_.clear();
   data_type_errors_.clear();
   crypto_errors_.clear();
@@ -70,11 +70,11 @@ void FailedDataTypesHandler::Reset() {
   unready_errors_.clear();
 }
 
-void FailedDataTypesHandler::ResetCryptoErrors() {
+void DataTypeStatusTable::ResetCryptoErrors() {
   crypto_errors_.clear();
 }
 
-void FailedDataTypesHandler::ResetPersistenceErrorsFrom(
+void DataTypeStatusTable::ResetPersistenceErrorsFrom(
     syncer::ModelTypeSet purged_types) {
   for (syncer::ModelTypeSet::Iterator iter = purged_types.First(); iter.Good();
        iter.Inc()) {
@@ -82,15 +82,15 @@ void FailedDataTypesHandler::ResetPersistenceErrorsFrom(
   }
 }
 
-bool FailedDataTypesHandler::ResetDataTypeErrorFor(syncer::ModelType type) {
+bool DataTypeStatusTable::ResetDataTypeErrorFor(syncer::ModelType type) {
   return data_type_errors_.erase(type) > 0;
 }
 
-bool FailedDataTypesHandler::ResetUnreadyErrorFor(syncer::ModelType type) {
+bool DataTypeStatusTable::ResetUnreadyErrorFor(syncer::ModelType type) {
   return unready_errors_.erase(type) > 0;
 }
 
-FailedDataTypesHandler::TypeErrorMap FailedDataTypesHandler::GetAllErrors()
+DataTypeStatusTable::TypeErrorMap DataTypeStatusTable::GetAllErrors()
     const {
   TypeErrorMap result;
   result.insert(data_type_errors_.begin(), data_type_errors_.end());
@@ -101,14 +101,14 @@ FailedDataTypesHandler::TypeErrorMap FailedDataTypesHandler::GetAllErrors()
   return result;
 }
 
-syncer::ModelTypeSet FailedDataTypesHandler::GetFailedTypes() const {
+syncer::ModelTypeSet DataTypeStatusTable::GetFailedTypes() const {
   syncer::ModelTypeSet result = GetFatalErrorTypes();
   result.PutAll(GetCryptoErrorTypes());
   result.PutAll(GetUnreadyErrorTypes());
   return result;
 }
 
-syncer::ModelTypeSet FailedDataTypesHandler::GetFatalErrorTypes()
+syncer::ModelTypeSet DataTypeStatusTable::GetFatalErrorTypes()
     const {
   syncer::ModelTypeSet result;
   result.PutAll(GetTypesFromErrorMap(data_type_errors_));
@@ -116,28 +116,28 @@ syncer::ModelTypeSet FailedDataTypesHandler::GetFatalErrorTypes()
   return result;
 }
 
-syncer::ModelTypeSet FailedDataTypesHandler::GetCryptoErrorTypes() const {
+syncer::ModelTypeSet DataTypeStatusTable::GetCryptoErrorTypes() const {
   syncer::ModelTypeSet result = GetTypesFromErrorMap(crypto_errors_);
   return result;
 }
 
-syncer::ModelTypeSet FailedDataTypesHandler::GetPersistenceErrorTypes() const {
+syncer::ModelTypeSet DataTypeStatusTable::GetPersistenceErrorTypes() const {
   syncer::ModelTypeSet result = GetTypesFromErrorMap(persistence_errors_);
   return result;
 }
 
-syncer::ModelTypeSet FailedDataTypesHandler::GetUnreadyErrorTypes() const {
+syncer::ModelTypeSet DataTypeStatusTable::GetUnreadyErrorTypes() const {
   syncer::ModelTypeSet result = GetTypesFromErrorMap(unready_errors_);
   return result;
 }
 
-syncer::ModelTypeSet FailedDataTypesHandler::GetUnrecoverableErrorTypes()
+syncer::ModelTypeSet DataTypeStatusTable::GetUnrecoverableErrorTypes()
     const {
   syncer::ModelTypeSet result = GetTypesFromErrorMap(unrecoverable_errors_);
   return result;
 }
 
-syncer::SyncError FailedDataTypesHandler::GetUnrecoverableError() const {
+syncer::SyncError DataTypeStatusTable::GetUnrecoverableError() const {
   // Just return the first one. It is assumed all the unrecoverable errors
   // have the same cause. The others are just tracked to know which types
   // were involved.
@@ -146,7 +146,7 @@ syncer::SyncError FailedDataTypesHandler::GetUnrecoverableError() const {
               : unrecoverable_errors_.begin()->second);
 }
 
-bool FailedDataTypesHandler::AnyFailedDataType() const {
+bool DataTypeStatusTable::AnyFailedDataType() const {
   // Note: persistence errors are not failed types. They just trigger automatic
   // unapply + getupdates, at which point they are associated like normal.
   return unrecoverable_errors_.empty() ||
diff --git a/components/sync_driver/failed_data_types_handler.h b/components/sync_driver/data_type_status_table.h
index 985e759..f3bb19a 100644
--- a/components/sync_driver/failed_data_types_handler.h
+++ b/components/sync_driver/data_type_status_table.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef COMPONENTS_SYNC_DRIVER_FAILED_DATA_TYPES_HANDLER_H_
-#define COMPONENTS_SYNC_DRIVER_FAILED_DATA_TYPES_HANDLER_H_
+#ifndef COMPONENTS_SYNC_DRIVER_DATA_TYPE_STATUS_TABLE_H_
+#define COMPONENTS_SYNC_DRIVER_DATA_TYPE_STATUS_TABLE_H_
 
 #include <string>
 
@@ -12,12 +12,14 @@
 namespace sync_driver {
 
 // Class to keep track of data types that have encountered an error during sync.
-class FailedDataTypesHandler {
+class DataTypeStatusTable {
  public:
   typedef std::map<syncer::ModelType, syncer::SyncError> TypeErrorMap;
 
-  explicit FailedDataTypesHandler();
-  ~FailedDataTypesHandler();
+  explicit DataTypeStatusTable();
+  ~DataTypeStatusTable();
+
+  // Copy and assign welcome.
 
   // Update the failed datatypes. Types will be added to their corresponding
   // error map based on their |error_type()|.
@@ -90,10 +92,8 @@ class FailedDataTypesHandler {
   // List of data types that could not start due to not being ready. These can
   // be marked as ready by calling ResetUnreadyErrorFor(..).
   TypeErrorMap unready_errors_;
-
-  DISALLOW_COPY_AND_ASSIGN(FailedDataTypesHandler);
 };
 
 }  // namespace sync_driver
 
-#endif  // COMPONENTS_SYNC_DRIVER_FAILED_DATA_TYPES_HANDLER_H_
+#endif  // COMPONENTS_SYNC_DRIVER_DATA_TYPE_STATUS_TABLE_H_