[Sync] Add support for dynamically enabling/disabling types

components/sync_driver/failed_data_types_handler.cc

Index: components/sync_driver/failed_data_types_handler.cc
diff --git a/components/sync_driver/failed_data_types_handler.cc b/components/sync_driver/failed_data_types_handler.cc
index bf6dde192d6cb9139f846d3008342360a02ed791..0a1289a0267da3cfd21e56892e76970d35898b48 100644
--- a/components/sync_driver/failed_data_types_handler.cc
+++ b/components/sync_driver/failed_data_types_handler.cc
@@ -38,9 +38,14 @@ bool FailedDataTypesHandler::UpdateFailedDataTypes(const TypeErrorMap& errors) {
        ++iter) {
     syncer::SyncError::ErrorType failure_type = iter->second.error_type();
     switch (failure_type) {
+      case syncer::SyncError::UNSET:
+        NOTREACHED();

[stanisc, 2014/06/10 21:21:42]

Wouldn't it be better to keep the default case instead of the specific UNSET
case?

[Nicolas Zea, 2014/06/19 00:04:22]

I prefer to not have default cases, as you'll then get a compile error if you
forget to handle a case (rather than a runtime error).

[stanisc, 2014/06/19 17:07:03]

OK. I haven't realized the compiler would error out in that case because that
isn't default behavior. 

+        break;
       case syncer::SyncError::UNRECOVERABLE_ERROR:
+        unrecoverable_errors_.insert(*iter);
+        break;
       case syncer::SyncError::DATATYPE_ERROR:
-        fatal_errors_.insert(*iter);
+        data_type_errors_.insert(*iter);
         break;
       case syncer::SyncError::CRYPTO_ERROR:
         crypto_errors_.insert(*iter);
@@ -48,17 +53,20 @@ bool FailedDataTypesHandler::UpdateFailedDataTypes(const TypeErrorMap& errors) {
       case syncer::SyncError::PERSISTENCE_ERROR:
         persistence_errors_.insert(*iter);
         break;
-      default:
-        NOTREACHED();
+      case syncer::SyncError::UNREADY_ERROR:
+        unready_errors_.insert(*iter);
+        break;
     }
   }
   return true;
 }
 
 void FailedDataTypesHandler::Reset() {
-  fatal_errors_.clear();
+  unrecoverable_errors_.clear();
+  data_type_errors_.clear();
   crypto_errors_.clear();
   persistence_errors_.clear();
+  unready_errors_.clear();
 }
 
 void FailedDataTypesHandler::ResetCryptoErrors() {
@@ -73,15 +81,22 @@ void FailedDataTypesHandler::ResetPersistenceErrorsFrom(
   }
 }
 
+bool FailedDataTypesHandler::ResetDataTypeErrorFor(syncer::ModelType type) {
+  return data_type_errors_.erase(type) > 0;
+}
+
+bool FailedDataTypesHandler::ResetUnreadyErrorFor(syncer::ModelType type) {
+  return unready_errors_.erase(type) > 0;
+}
+
 FailedDataTypesHandler::TypeErrorMap FailedDataTypesHandler::GetAllErrors()
     const {
   TypeErrorMap result;
-
-  if (AnyFailedDataType()) {
-    result = fatal_errors_;
-    result.insert(crypto_errors_.begin(), crypto_errors_.end());
-    result.insert(persistence_errors_.begin(), persistence_errors_.end());
-  }
+  result = unrecoverable_errors_;
+  result.insert(data_type_errors_.begin(), data_type_errors_.end());
+  result.insert(crypto_errors_.begin(), crypto_errors_.end());
+  result.insert(persistence_errors_.begin(), persistence_errors_.end());
+  result.insert(unready_errors_.begin(), unready_errors_.end());
   return result;
 }
 
@@ -91,8 +106,11 @@ syncer::ModelTypeSet FailedDataTypesHandler::GetFailedTypes() const {
   return result;
 }
 
-syncer::ModelTypeSet FailedDataTypesHandler::GetFatalErrorTypes() const {
-  return GetTypesFromErrorMap(fatal_errors_);
+syncer::ModelTypeSet FailedDataTypesHandler::GetFatalErrorTypes()
+    const {
+  syncer::ModelTypeSet result = GetTypesFromErrorMap(unrecoverable_errors_);
+  result.PutAll(GetTypesFromErrorMap(data_type_errors_));
+  return result;
 }
 
 syncer::ModelTypeSet FailedDataTypesHandler::GetCryptoErrorTypes() const {
@@ -105,10 +123,17 @@ syncer::ModelTypeSet FailedDataTypesHandler::GetPersistenceErrorTypes() const {
   return result;
 }
 
+syncer::ModelTypeSet FailedDataTypesHandler::GetUnreadyErrorTypes() const {
+  syncer::ModelTypeSet result = GetTypesFromErrorMap(unready_errors_);
+  return result;
+}
+
 bool FailedDataTypesHandler::AnyFailedDataType() const {
   // Note: persistence errors are not failed types. They just trigger automatic
   // unapply + getupdates, at which point they are associated like normal.
-  return !fatal_errors_.empty() || !crypto_errors_.empty();
+  return !unrecoverable_errors_.empty() ||
+         !data_type_errors_.empty() ||
+         !crypto_errors_.empty();
 }
 
 }  // namespace browser_sync