Invalidation trickles mega-patch

sync/internal_api/public/base/invalidation.cc

Index: sync/internal_api/public/base/invalidation.cc
diff --git a/sync/internal_api/public/base/invalidation.cc b/sync/internal_api/public/base/invalidation.cc
index b503d07c4afa99905a688d70eeb85c8d6d80a425..0c0e709ff9281a8d40e94dbc07c4e04bff39bed3 100644
--- a/sync/internal_api/public/base/invalidation.cc
+++ b/sync/internal_api/public/base/invalidation.cc
@@ -5,100 +5,156 @@
 #include "sync/internal_api/public/base/invalidation.h"
 
 #include <cstddef>
+
+#include "base/json/json_string_value_serializer.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
+#include "sync/notifier/dropped_invalidation_tracker.h"
+#include "sync/notifier/invalidation_util.h"
 
 namespace syncer {
 
 namespace {
-// Hopefully enough bytes for uniqueness.
-const size_t kBytesInHandle = 16;
-}  // namespace
+const char kObjectIdKey[] = "objectId";
+const char kIsUnknownVersionKey[] = "isUnknownVersion";
+const char kVersionKey[] = "version";
+const char kPayloadKey[] = "payload";
+}
 
-AckHandle AckHandle::CreateUnique() {
-  // This isn't a valid UUID, so we don't attempt to format it like one.
-  uint8 random_bytes[kBytesInHandle];
-  base::RandBytes(random_bytes, sizeof(random_bytes));
-  return AckHandle(base::HexEncode(random_bytes, sizeof(random_bytes)),
-                   base::Time::Now());
+Invalidation Invalidation::Init(
+    const invalidation::ObjectId& id,
+    int64 version,
+    const std::string& payload) {
+  return Invalidation(id, false, version, payload, AckHandle::CreateUnique());
 }
 
-AckHandle AckHandle::InvalidAckHandle() {
-  return AckHandle(std::string(), base::Time());
+Invalidation Invalidation::InitUnknownVersion(
+    const invalidation::ObjectId& id) {
+  return Invalidation(id, true, -1, "", AckHandle::CreateUnique());
 }
 
-bool AckHandle::Equals(const AckHandle& other) const {
-  return state_ == other.state_ && timestamp_ == other.timestamp_;
+Invalidation Invalidation::InitFromDroppedInvalidation(
+    const Invalidation& dropped) {
+  return Invalidation(dropped.id_, true, -1, "", dropped.ack_handle_);
 }
 
-scoped_ptr<base::DictionaryValue> AckHandle::ToValue() const {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  value->SetString("state", state_);
-  value->SetString("timestamp",
-                   base::Int64ToString(timestamp_.ToInternalValue()));
-  return value.Pass();
+Invalidation::Invalidation()
+  : ack_handle_(AckHandle::InvalidAckHandle()) {}
+
+Invalidation::~Invalidation() {}
+
+invalidation::ObjectId Invalidation::GetObjectId() const {
+  return id_;
 }
 
-bool AckHandle::ResetFromValue(const base::DictionaryValue& value) {
-  if (!value.GetString("state", &state_))
-    return false;
-  std::string timestamp_as_string;
-  if (!value.GetString("timestamp", &timestamp_as_string))
-    return false;
-  int64 timestamp_value;
-  if (!base::StringToInt64(timestamp_as_string, &timestamp_value))
-    return false;
-  timestamp_ = base::Time::FromInternalValue(timestamp_value);
-  return true;
+bool Invalidation::IsUnknownVersion() const {
+  return is_unknown_version_;
 }
 
-bool AckHandle::IsValid() const {
-  return !state_.empty();
+int64 Invalidation::GetVersion() const {
+  DCHECK(!is_unknown_version_);
+  return version_;
 }
 
-AckHandle::AckHandle(const std::string& state, base::Time timestamp)
-    : state_(state), timestamp_(timestamp) {
+const std::string& Invalidation::GetPayload() const {
+  DCHECK(!is_unknown_version_);
+  return payload_;
 }
 
-AckHandle::~AckHandle() {
+const AckHandle& Invalidation::GetAckHandle() const {
+  return ack_handle_;
 }
 
-const int64 Invalidation::kUnknownVersion = -1;
+void Invalidation::SetAckHandler(syncer::WeakHandle<AckHandler> handler) {
+  ack_handler_ = handler;
+}
 
-Invalidation::Invalidation()
-    : version(kUnknownVersion), ack_handle(AckHandle::InvalidAckHandle()) {
+bool Invalidation::SupportsAcknowledgement() const {
+  return ack_handler_.IsInitialized();
 }
 
-Invalidation::~Invalidation() {
+void Invalidation::Acknowledge() const {
+  if (SupportsAcknowledgement()) {
+    ack_handler_.Call(FROM_HERE,
+                      &AckHandler::Acknowledge,
+                      id_,
+                      ack_handle_);
+  }
 }
 
-bool Invalidation::Equals(const Invalidation& other) const {
-  return (version == other.version) && (payload == other.payload) &&
-      ack_handle.Equals(other.ack_handle);
+void Invalidation::Drop(DroppedInvalidationTracker* tracker) const {
+  DCHECK(tracker->GetObjectId() == GetObjectId());
+  tracker->Drop(ack_handler_, ack_handle_);
+}
+
+bool Invalidation::operator==(const Invalidation& other) const {
+  return id_ == other.id_
+      && is_unknown_version_ == other.is_unknown_version_
+      && version_ == other.version_
+      && payload_ == other.payload_;
 }
 
 scoped_ptr<base::DictionaryValue> Invalidation::ToValue() const {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  value->SetString("version", base::Int64ToString(version));
-  value->SetString("payload", payload);
-  value->Set("ackHandle", ack_handle.ToValue().release());
+  value->Set(kObjectIdKey, ObjectIdToValue(id_).release());
+  if (is_unknown_version_) {
+    value->SetBoolean(kIsUnknownVersionKey, true);
+  } else {
+    value->SetBoolean(kIsUnknownVersionKey, false);
+    value->SetString(kVersionKey, base::Int64ToString(version_));
+    value->SetString(kPayloadKey, payload_);
+  }
   return value.Pass();
 }
 
 bool Invalidation::ResetFromValue(const base::DictionaryValue& value) {
-  const base::DictionaryValue* ack_handle_value = NULL;
-  std::string version_as_string;
-  if (value.GetString("version", &version_as_string)) {
-    if (!base::StringToInt64(version_as_string, &version))
-      return false;
+  const base::DictionaryValue* object_id_dict;
+  if (!value.GetDictionary(kObjectIdKey, &object_id_dict)
+      || !ObjectIdFromValue(*object_id_dict, &id_)) {
+    DLOG(WARNING) << "Failed to parse id";
+    return false;
+  }
+  if (!value.GetBoolean(kIsUnknownVersionKey, &is_unknown_version_)) {
+    DLOG(WARNING) << "Failed to parse is_unknown_version flag";
+    return false;
+  }
+  if (is_unknown_version_) {
+    version_ = -1;
+    payload_ = "";
   } else {
-    version = kUnknownVersion;
+    std::string version_as_string;
+    if (!value.GetString(kVersionKey, &version_as_string)
+        || !base::StringToInt64(version_as_string, &version_)) {
+      DLOG(WARNING) << "Failed to parse version";
+      return false;
+    }
+    if (!value.GetString(kPayloadKey, &payload_)) {
+      DLOG(WARNING) << "Failed to parse payload";
+      return false;
+    }
   }
-  return
-      value.GetString("payload", &payload) &&
-      value.GetDictionary("ackHandle", &ack_handle_value) &&
-      ack_handle.ResetFromValue(*ack_handle_value);
+  return true;
 }
 
+std::string Invalidation::ToString() const {
+  std::string output;
+  JSONStringValueSerializer serializer(&output);
+  serializer.set_pretty_print(true);
+  serializer.Serialize(*ToValue().get());
+  return output;
+}
+
+Invalidation::Invalidation(
+    const invalidation::ObjectId& id,
+    bool is_unknown_version,
+    int64 version,
+    const std::string& payload,
+    AckHandle ack_handle)
+  : id_(id),
+    is_unknown_version_(is_unknown_version),
+    version_(version),
+    payload_(payload),
+    ack_handle_(ack_handle) {}
+
 }  // namespace syncer