Refactor common invalidation framework types

sync/notifier/single_object_invalidation_set.cc

Index: sync/notifier/single_object_invalidation_set.cc
diff --git a/sync/notifier/single_object_invalidation_set.cc b/sync/notifier/single_object_invalidation_set.cc
new file mode 100644
index 0000000000000000000000000000000000000000..55202bb148ec34196bbfa0257523a01af9327d01
--- /dev/null
+++ b/sync/notifier/single_object_invalidation_set.cc
@@ -0,0 +1,130 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "sync/notifier/single_object_invalidation_set.h"
+
+#include "base/values.h"
+#include "sync/notifier/invalidation_util.h"
+
+namespace syncer {
+
+bool InvalidationVersionLessThan::operator()(
+    const Invalidation& a,
+    const Invalidation& b) {
+  DCHECK(a.object_id() == b.object_id())
+      << "a: " << ObjectIdToString(a.object_id()) << ", "
+      << "b: " << ObjectIdToString(a.object_id());
+
+  if (a.is_unknown_version() && !b.is_unknown_version())
+    return true;
+
+  if (!a.is_unknown_version() && b.is_unknown_version())
+    return false;
+
+  if (a.is_unknown_version() && b.is_unknown_version())
+    return false;
+
+  return a.version() < b.version();
+}
+
+SingleObjectInvalidationSet::SingleObjectInvalidationSet() {}
+
+SingleObjectInvalidationSet::~SingleObjectInvalidationSet() {}
+
+void SingleObjectInvalidationSet::Insert(const Invalidation& invalidation) {
+  invalidations_.insert(invalidation);
+}
+
+void SingleObjectInvalidationSet::InsertAll(
+    const SingleObjectInvalidationSet& other) {
+  invalidations_.insert(other.begin(), other.end());
+}
+
+void SingleObjectInvalidationSet::Clear() {
+  invalidations_.clear();
+}
+
+bool SingleObjectInvalidationSet::StartsWithUnknownVersion() const {
+  return !invalidations_.empty() &&
+      invalidations_.begin()->is_unknown_version();
+}
+
+size_t SingleObjectInvalidationSet::GetSize() const {
+  return invalidations_.size();
+}
+
+bool SingleObjectInvalidationSet::IsEmpty() const {
+  return invalidations_.empty();
+}
+
+namespace {
+
+struct InvalidationComparator {
+  bool operator()(const Invalidation& inv1, const Invalidation& inv2) {
+    return inv1.Equals(inv2);
+  }
+};
+
+}  // namespace
+
+bool SingleObjectInvalidationSet::operator==(
+    const SingleObjectInvalidationSet& other) const {
+  return std::equal(invalidations_.begin(),
+                    invalidations_.end(),
+                    other.invalidations_.begin(),
+                    InvalidationComparator());
+}
+
+SingleObjectInvalidationSet::const_iterator
+SingleObjectInvalidationSet::begin() const {
+  return invalidations_.begin();
+}
+
+SingleObjectInvalidationSet::const_iterator
+SingleObjectInvalidationSet::end() const {
+  return invalidations_.end();
+}
+
+SingleObjectInvalidationSet::const_reverse_iterator
+SingleObjectInvalidationSet::rbegin() const {
+  return invalidations_.rbegin();
+}
+
+SingleObjectInvalidationSet::const_reverse_iterator
+SingleObjectInvalidationSet::rend() const {
+  return invalidations_.rend();
+}
+
+const Invalidation& SingleObjectInvalidationSet::back() const {
+  return *invalidations_.rbegin();
+}
+
+scoped_ptr<base::ListValue> SingleObjectInvalidationSet::ToValue() const {
+  scoped_ptr<base::ListValue> value(new ListValue);
+  for (InvalidationsSet::const_iterator it = invalidations_.begin();
+       it != invalidations_.end(); ++it) {
+    value->Append(it->ToValue().release());
+  }
+  return value.Pass();
+}
+
+bool SingleObjectInvalidationSet::ResetFromValue(
+    const base::ListValue& list) {
+  for (size_t i = 0; i < list.GetSize(); ++i) {
+    const base::DictionaryValue* dict;
+    if (!list.GetDictionary(i, &dict)) {
+      DLOG(WARNING) << "Could not find invalidation at index " << i;
+      return false;
+    }
+    scoped_ptr<Invalidation> invalidation = Invalidation::InitFromValue(*dict);
+    if (!invalidation) {
+      DLOG(WARNING) << "Failed to parse invalidation at index " << i;
+      return false;
+    }
+    invalidations_.insert(*invalidation);
+  }
+  return true;
+}
+
+}  // namespace syncer