• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
GetTypesFromErrorMap(const FailedDataTypesHandler::TypeErrorMap & errors)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 
FailedDataTypesHandler()27 FailedDataTypesHandler::FailedDataTypesHandler() {
28 }
29 
~FailedDataTypesHandler()30 FailedDataTypesHandler::~FailedDataTypesHandler() {
31 }
32 
UpdateFailedDataTypes(const TypeErrorMap & errors)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 
Reset()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 
ResetCryptoErrors()72 void FailedDataTypesHandler::ResetCryptoErrors() {
73   crypto_errors_.clear();
74 }
75 
ResetPersistenceErrorsFrom(syncer::ModelTypeSet purged_types)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 
ResetDataTypeErrorFor(syncer::ModelType type)84 bool FailedDataTypesHandler::ResetDataTypeErrorFor(syncer::ModelType type) {
85   return data_type_errors_.erase(type) > 0;
86 }
87 
ResetUnreadyErrorFor(syncer::ModelType type)88 bool FailedDataTypesHandler::ResetUnreadyErrorFor(syncer::ModelType type) {
89   return unready_errors_.erase(type) > 0;
90 }
91 
GetAllErrors() const92 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 
GetFailedTypes() const103 syncer::ModelTypeSet FailedDataTypesHandler::GetFailedTypes() const {
104   syncer::ModelTypeSet result = GetFatalErrorTypes();
105   result.PutAll(GetCryptoErrorTypes());
106   result.PutAll(GetUnreadyErrorTypes());
107   return result;
108 }
109 
GetFatalErrorTypes() const110 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 
GetCryptoErrorTypes() const117 syncer::ModelTypeSet FailedDataTypesHandler::GetCryptoErrorTypes() const {
118   syncer::ModelTypeSet result = GetTypesFromErrorMap(crypto_errors_);
119   return result;
120 }
121 
GetPersistenceErrorTypes() const122 syncer::ModelTypeSet FailedDataTypesHandler::GetPersistenceErrorTypes() const {
123   syncer::ModelTypeSet result = GetTypesFromErrorMap(persistence_errors_);
124   return result;
125 }
126 
GetUnreadyErrorTypes() const127 syncer::ModelTypeSet FailedDataTypesHandler::GetUnreadyErrorTypes() const {
128   syncer::ModelTypeSet result = GetTypesFromErrorMap(unready_errors_);
129   return result;
130 }
131 
AnyFailedDataType() const132 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