Home | History | Annotate | Download | only in sync_driver 
      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