1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "components/sync_driver/data_type_manager.h" 6 #include "components/sync_driver/failed_data_types_handler.h" 7 8 using browser_sync::DataTypeManager; 9 10 namespace browser_sync { 11 12 namespace { 13 14 syncer::ModelTypeSet GetTypesFromErrorMap( 15 const FailedDataTypesHandler::TypeErrorMap& errors) { 16 syncer::ModelTypeSet result; 17 for (FailedDataTypesHandler::TypeErrorMap::const_iterator it = errors.begin(); 18 it != errors.end(); ++it) { 19 DCHECK(!result.Has(it->first)); 20 result.Put(it->first); 21 } 22 return result; 23 } 24 25 } // namespace 26 27 FailedDataTypesHandler::FailedDataTypesHandler() { 28 } 29 30 FailedDataTypesHandler::~FailedDataTypesHandler() { 31 } 32 33 bool FailedDataTypesHandler::UpdateFailedDataTypes(const TypeErrorMap& errors) { 34 if (errors.empty()) 35 return false; 36 37 for (TypeErrorMap::const_iterator iter = errors.begin(); iter != errors.end(); 38 ++iter) { 39 syncer::SyncError::ErrorType failure_type = iter->second.error_type(); 40 switch (failure_type) { 41 case syncer::SyncError::UNSET: 42 NOTREACHED(); 43 break; 44 case syncer::SyncError::UNRECOVERABLE_ERROR: 45 unrecoverable_errors_.insert(*iter); 46 break; 47 case syncer::SyncError::DATATYPE_ERROR: 48 data_type_errors_.insert(*iter); 49 break; 50 case syncer::SyncError::CRYPTO_ERROR: 51 crypto_errors_.insert(*iter); 52 break; 53 case syncer::SyncError::PERSISTENCE_ERROR: 54 persistence_errors_.insert(*iter); 55 break; 56 case syncer::SyncError::UNREADY_ERROR: 57 unready_errors_.insert(*iter); 58 break; 59 } 60 } 61 return true; 62 } 63 64 void FailedDataTypesHandler::Reset() { 65 unrecoverable_errors_.clear(); 66 data_type_errors_.clear(); 67 crypto_errors_.clear(); 68 persistence_errors_.clear(); 69 unready_errors_.clear(); 70 } 71 72 void FailedDataTypesHandler::ResetCryptoErrors() { 73 crypto_errors_.clear(); 74 } 75 76 void FailedDataTypesHandler::ResetPersistenceErrorsFrom( 77 syncer::ModelTypeSet purged_types) { 78 for (syncer::ModelTypeSet::Iterator iter = purged_types.First(); iter.Good(); 79 iter.Inc()) { 80 persistence_errors_.erase(iter.Get()); 81 } 82 } 83 84 bool FailedDataTypesHandler::ResetDataTypeErrorFor(syncer::ModelType type) { 85 return data_type_errors_.erase(type) > 0; 86 } 87 88 bool FailedDataTypesHandler::ResetUnreadyErrorFor(syncer::ModelType type) { 89 return unready_errors_.erase(type) > 0; 90 } 91 92 FailedDataTypesHandler::TypeErrorMap FailedDataTypesHandler::GetAllErrors() 93 const { 94 TypeErrorMap result; 95 result = unrecoverable_errors_; 96 result.insert(data_type_errors_.begin(), data_type_errors_.end()); 97 result.insert(crypto_errors_.begin(), crypto_errors_.end()); 98 result.insert(persistence_errors_.begin(), persistence_errors_.end()); 99 result.insert(unready_errors_.begin(), unready_errors_.end()); 100 return result; 101 } 102 103 syncer::ModelTypeSet FailedDataTypesHandler::GetFailedTypes() const { 104 syncer::ModelTypeSet result = GetFatalErrorTypes(); 105 result.PutAll(GetCryptoErrorTypes()); 106 result.PutAll(GetUnreadyErrorTypes()); 107 return result; 108 } 109 110 syncer::ModelTypeSet FailedDataTypesHandler::GetFatalErrorTypes() 111 const { 112 syncer::ModelTypeSet result = GetTypesFromErrorMap(unrecoverable_errors_); 113 result.PutAll(GetTypesFromErrorMap(data_type_errors_)); 114 return result; 115 } 116 117 syncer::ModelTypeSet FailedDataTypesHandler::GetCryptoErrorTypes() const { 118 syncer::ModelTypeSet result = GetTypesFromErrorMap(crypto_errors_); 119 return result; 120 } 121 122 syncer::ModelTypeSet FailedDataTypesHandler::GetPersistenceErrorTypes() const { 123 syncer::ModelTypeSet result = GetTypesFromErrorMap(persistence_errors_); 124 return result; 125 } 126 127 syncer::ModelTypeSet FailedDataTypesHandler::GetUnreadyErrorTypes() const { 128 syncer::ModelTypeSet result = GetTypesFromErrorMap(unready_errors_); 129 return result; 130 } 131 132 bool FailedDataTypesHandler::AnyFailedDataType() const { 133 // Note: persistence errors are not failed types. They just trigger automatic 134 // unapply + getupdates, at which point they are associated like normal. 135 return !unrecoverable_errors_.empty() || 136 !data_type_errors_.empty() || 137 !crypto_errors_.empty(); 138 } 139 140 } // namespace browser_sync 141