Invalidation trickles mega-patch

sync/internal_api/public/base/invalidation.h

 // Copyright 2012 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.
 
 #ifndef SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_H_
 #define SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/time/time.h"
+#include "base/values.h"
+#include "google/cacheinvalidation/include/types.h"
 #include "sync/base/sync_export.h"
-
-namespace base {
-class DictionaryValue;
-}  // namespace
+#include "sync/internal_api/public/base/ack_handle.h"
+#include "sync/internal_api/public/util/weak_handle.h"
 
 namespace syncer {
 
-// Opaque class that represents a local ack handle. We don't reuse the
-// invalidation ack handles to avoid unnecessary dependencies.
-class SYNC_EXPORT AckHandle {
- public:
-  static AckHandle CreateUnique();
-  static AckHandle InvalidAckHandle();
-
-  bool Equals(const AckHandle& other) const;
-
-  scoped_ptr<base::DictionaryValue> ToValue() const;
-  bool ResetFromValue(const base::DictionaryValue& value);
-
-  bool IsValid() const;
-
-  ~AckHandle();
-
- private:
-  // Explicitly copyable and assignable for STL containers.
-  AckHandle(const std::string& state, base::Time timestamp);
-
-  std::string state_;
-  base::Time timestamp_;
-};
+class DroppedInvalidationTracker;
+class AckHandler;
 
 // Represents a local invalidation, and is roughly analogous to
-// invalidation::Invalidation. It contains a version (which may be
-// kUnknownVersion), a payload (which may be empty) and an
-// associated ack handle that an InvalidationHandler implementation can use to
-// acknowledge receipt of the invalidation. It does not embed the object ID,
-// since it is typically associated with it through ObjectIdInvalidationMap.
-struct SYNC_EXPORT Invalidation {
-  static const int64 kUnknownVersion;
+// invalidation::Invalidation.
+class SYNC_EXPORT Invalidation {
+ public:
+  // Factory functions.
+  static Invalidation Init(
+      const invalidation::ObjectId& id,
+      int64 version,
+      const std::string& payload);
+  static Invalidation InitUnknownVersion(const invalidation::ObjectId& id);
+  static Invalidation InitFromDroppedInvalidation(const Invalidation& dropped);
 
   Invalidation();
   ~Invalidation();
 
-  bool Equals(const Invalidation& other) const;
+  // Compares two invalidations.  The comparison ignores ack-tracking state.
+  bool operator==(const Invalidation& other) const;
+
+  invalidation::ObjectId GetObjectId() const;
+  bool IsUnknownVersion() const;
+
+  // These functions may be called only if IsUnknownVersion() returns false.
+  int64 GetVersion() const;
+  const std::string& GetPayload() const;
+
+  void Acknowledge() const;
+  void Drop(DroppedInvalidationTracker* tracker) const;
+
+  const AckHandle& GetAckHandle() const;
+
+  void SetAckHandler(syncer::WeakHandle<AckHandler> ack_handler);
+  bool SupportsAcknowledgement() const;
 
   scoped_ptr<base::DictionaryValue> ToValue() const;
   bool ResetFromValue(const base::DictionaryValue& value);
+  std::string ToString() const;
 
-  int64 version;
-  std::string payload;
-  AckHandle ack_handle;
+ private:
+  Invalidation(const invalidation::ObjectId& id,
+               bool is_unknown_version,
+               int64 version,
+               const std::string& payload,
+               AckHandle ack_handle);
+
+  invalidation::ObjectId id_;
+  bool is_unknown_version_;
+  int64 version_;
+  std::string payload_;
+
+  AckHandle ack_handle_;
+  syncer::WeakHandle<AckHandler> ack_handler_;
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_H_