1// Copyright 2013 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 "sync/notifier/unacked_invalidation_set.h" 6 7#include "base/strings/string_number_conversions.h" 8#include "sync/internal_api/public/base/ack_handle.h" 9#include "sync/notifier/object_id_invalidation_map.h" 10 11namespace { 12 13const char kSourceKey[] = "source"; 14const char kNameKey[] = "name"; 15const char kInvalidationListKey[] = "invalidation-list"; 16 17} // namespace 18 19namespace syncer { 20 21const size_t UnackedInvalidationSet::kMaxBufferedInvalidations = 5; 22 23// static 24UnackedInvalidationSet::UnackedInvalidationSet( 25 invalidation::ObjectId id) 26 : registered_(false), 27 object_id_(id) {} 28 29UnackedInvalidationSet::UnackedInvalidationSet( 30 const UnackedInvalidationSet& other) 31 : registered_(other.registered_), 32 object_id_(other.object_id_), 33 invalidations_(other.invalidations_) { 34} 35 36UnackedInvalidationSet::~UnackedInvalidationSet() {} 37 38const invalidation::ObjectId& UnackedInvalidationSet::object_id() const { 39 return object_id_; 40} 41 42void UnackedInvalidationSet::Add( 43 const Invalidation& invalidation) { 44 SingleObjectInvalidationSet set; 45 set.Insert(invalidation); 46 AddSet(set); 47 if (!registered_) 48 Truncate(kMaxBufferedInvalidations); 49} 50 51void UnackedInvalidationSet::AddSet( 52 const SingleObjectInvalidationSet& invalidations) { 53 invalidations_.insert(invalidations.begin(), invalidations.end()); 54 if (!registered_) 55 Truncate(kMaxBufferedInvalidations); 56} 57 58void UnackedInvalidationSet::ExportInvalidations( 59 WeakHandle<AckHandler> ack_handler, 60 ObjectIdInvalidationMap* out) const { 61 for (SingleObjectInvalidationSet::const_iterator it = invalidations_.begin(); 62 it != invalidations_.end(); ++it) { 63 // Copy the invalidation and set the copy's ack_handler. 64 Invalidation inv(*it); 65 inv.set_ack_handler(ack_handler); 66 out->Insert(inv); 67 } 68} 69 70void UnackedInvalidationSet::Clear() { 71 invalidations_.clear(); 72} 73 74void UnackedInvalidationSet::SetHandlerIsRegistered() { 75 registered_ = true; 76} 77 78void UnackedInvalidationSet::SetHandlerIsUnregistered() { 79 registered_ = false; 80 Truncate(kMaxBufferedInvalidations); 81} 82 83// Removes the matching ack handle from the list. 84void UnackedInvalidationSet::Acknowledge(const AckHandle& handle) { 85 bool handle_found = false; 86 for (SingleObjectInvalidationSet::const_iterator it = invalidations_.begin(); 87 it != invalidations_.end(); ++it) { 88 if (it->ack_handle().Equals(handle)) { 89 invalidations_.erase(*it); 90 handle_found = true; 91 break; 92 } 93 } 94 DLOG_IF(WARNING, !handle_found) 95 << "Unrecognized to ack for object " << ObjectIdToString(object_id_); 96 (void)handle_found; // Silence unused variable warning in release builds. 97} 98 99// Erase the invalidation with matching ack handle from the list. Also creates 100// an 'UnknownVersion' invalidation with the same ack handle and places it at 101// the beginning of the list. If an unknown version invalidation currently 102// exists, it is replaced. 103void UnackedInvalidationSet::Drop(const AckHandle& handle) { 104 SingleObjectInvalidationSet::const_iterator it; 105 for (it = invalidations_.begin(); it != invalidations_.end(); ++it) { 106 if (it->ack_handle().Equals(handle)) { 107 break; 108 } 109 } 110 if (it == invalidations_.end()) { 111 DLOG(WARNING) << "Unrecognized drop request for object " 112 << ObjectIdToString(object_id_); 113 return; 114 } 115 116 Invalidation unknown_version = Invalidation::InitFromDroppedInvalidation(*it); 117 invalidations_.erase(*it); 118 119 // If an unknown version is in the list, we remove it so we can replace it. 120 if (!invalidations_.empty() && invalidations_.begin()->is_unknown_version()) { 121 invalidations_.erase(*invalidations_.begin()); 122 } 123 124 invalidations_.insert(unknown_version); 125} 126 127scoped_ptr<base::DictionaryValue> UnackedInvalidationSet::ToValue() const { 128 scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue); 129 value->SetString(kSourceKey, base::IntToString(object_id_.source())); 130 value->SetString(kNameKey, object_id_.name()); 131 132 scoped_ptr<base::ListValue> list_value(new base::ListValue); 133 for (InvalidationsSet::const_iterator it = invalidations_.begin(); 134 it != invalidations_.end(); ++it) { 135 list_value->Append(it->ToValue().release()); 136 } 137 value->Set(kInvalidationListKey, list_value.release()); 138 139 return value.Pass(); 140} 141 142bool UnackedInvalidationSet::ResetFromValue( 143 const base::DictionaryValue& value) { 144 std::string source_str; 145 if (!value.GetString(kSourceKey, &source_str)) { 146 DLOG(WARNING) << "Unable to deserialize source"; 147 return false; 148 } 149 int source = 0; 150 if (!base::StringToInt(source_str, &source)) { 151 DLOG(WARNING) << "Invalid source: " << source_str; 152 return false; 153 } 154 std::string name; 155 if (!value.GetString(kNameKey, &name)) { 156 DLOG(WARNING) << "Unable to deserialize name"; 157 return false; 158 } 159 object_id_ = invalidation::ObjectId(source, name); 160 const base::ListValue* invalidation_list = NULL; 161 if (!value.GetList(kInvalidationListKey, &invalidation_list) 162 || !ResetListFromValue(*invalidation_list)) { 163 // Earlier versions of this class did not set this field, so we don't treat 164 // parsing errors here as a fatal failure. 165 DLOG(WARNING) << "Unable to deserialize invalidation list."; 166 } 167 return true; 168} 169 170bool UnackedInvalidationSet::ResetListFromValue( 171 const base::ListValue& list) { 172 for (size_t i = 0; i < list.GetSize(); ++i) { 173 const base::DictionaryValue* dict; 174 if (!list.GetDictionary(i, &dict)) { 175 DLOG(WARNING) << "Failed to get invalidation dictionary at index " << i; 176 return false; 177 } 178 scoped_ptr<Invalidation> invalidation = Invalidation::InitFromValue(*dict); 179 if (!invalidation) { 180 DLOG(WARNING) << "Failed to parse invalidation at index " << i; 181 return false; 182 } 183 invalidations_.insert(*invalidation.get()); 184 } 185 return true; 186} 187 188void UnackedInvalidationSet::Truncate(size_t max_size) { 189 DCHECK_GT(max_size, 0U); 190 191 if (invalidations_.size() <= max_size) { 192 return; 193 } 194 195 while (invalidations_.size() > max_size) { 196 invalidations_.erase(*invalidations_.begin()); 197 } 198 199 // We dropped some invalidations. We remember the fact that an unknown 200 // amount of information has been lost by ensuring this list begins with 201 // an UnknownVersion invalidation. We remove the oldest remaining 202 // invalidation to make room for it. 203 invalidation::ObjectId id = invalidations_.begin()->object_id(); 204 invalidations_.erase(*invalidations_.begin()); 205 206 Invalidation unknown_version = Invalidation::InitUnknownVersion(id); 207 invalidations_.insert(unknown_version); 208} 209 210} // namespace syncer 211