Add version field to syncer::Invalidation.

sync/notifier/sync_invalidation_listener.cc

 // Copyright (c) 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.
 
 #include "sync/notifier/sync_invalidation_listener.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 187 matching lines @@
            << " to " << invalidation.version();
   invalidation_state_map_[id].version = invalidation.version();
   invalidation_state_map_[id].payload = payload;
   invalidation_state_tracker_.Call(
       FROM_HERE,
       &InvalidationStateTracker::SetMaxVersionAndPayload,
       id, invalidation.version(), payload);
 
   ObjectIdSet ids;
   ids.insert(id);
-  PrepareInvalidation(ids, payload, client, ack_handle);
+  PrepareInvalidation(ids, invalidation.version(), payload, client, ack_handle);
 }
 
 void SyncInvalidationListener::InvalidateUnknownVersion(
     invalidation::InvalidationClient* client,
     const invalidation::ObjectId& object_id,
     const invalidation::AckHandle& ack_handle) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(client, invalidation_client_.get());
   DVLOG(1) << "InvalidateUnknownVersion";
 
   ObjectIdSet ids;
   ids.insert(object_id);
-  PrepareInvalidation(ids, std::string(), client, ack_handle);
+  PrepareInvalidation(
+      ids,
+      Invalidation::kUnknownVersion,
+      std::string(),
+      client,
+      ack_handle);
 }
 
 // This should behave as if we got an invalidation with version
 // UNKNOWN_OBJECT_VERSION for all known data types.
 void SyncInvalidationListener::InvalidateAll(
     invalidation::InvalidationClient* client,
     const invalidation::AckHandle& ack_handle) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(client, invalidation_client_.get());
   DVLOG(1) << "InvalidateAll";
 
-  PrepareInvalidation(registered_ids_, std::string(), client, ack_handle);
+  PrepareInvalidation(
+      registered_ids_,
+      Invalidation::kUnknownVersion,
+      std::string(),
+      client,
+      ack_handle);
 }
 
 void SyncInvalidationListener::PrepareInvalidation(
     const ObjectIdSet& ids,
+    int64 version,
     const std::string& payload,
     invalidation::InvalidationClient* client,
     const invalidation::AckHandle& ack_handle) {
   DCHECK(CalledOnValidThread());
 
   // A server invalidation resets the local retry count.
   ack_tracker_.Ack(ids);
   invalidation_state_tracker_.Call(
       FROM_HERE,
       &InvalidationStateTracker::GenerateAckHandles,
       ids,
       base::MessageLoopProxy::current(),
       base::Bind(&SyncInvalidationListener::EmitInvalidation,
                  weak_ptr_factory_.GetWeakPtr(),
                  ids,
+                 version,
                  payload,
                  client,
                  ack_handle));
 }
 
 void SyncInvalidationListener::EmitInvalidation(
     const ObjectIdSet& ids,
+    int64 version,
     const std::string& payload,
     invalidation::InvalidationClient* client,
     const invalidation::AckHandle& ack_handle,
     const AckHandleMap& local_ack_handles) {
   DCHECK(CalledOnValidThread());
   ObjectIdInvalidationMap invalidation_map =
-      ObjectIdSetToInvalidationMap(ids, payload);
+      ObjectIdSetToInvalidationMap(ids, version, payload);
   for (AckHandleMap::const_iterator it = local_ack_handles.begin();
        it != local_ack_handles.end(); ++it) {
     // Update in-memory copy of the invalidation state.
     invalidation_state_map_[it->first].expected = it->second;
     invalidation_map[it->first].ack_handle = it->second;
   }
   ack_tracker_.Track(ids);
   delegate_->OnInvalidate(invalidation_map);
   client->Acknowledge(ack_handle);
 }
 
 void SyncInvalidationListener::OnTimeout(const ObjectIdSet& ids) {
   ObjectIdInvalidationMap invalidation_map;
   for (ObjectIdSet::const_iterator it = ids.begin(); it != ids.end(); ++it) {
     Invalidation invalidation;
     invalidation.ack_handle = invalidation_state_map_[*it].expected;
+    invalidation.version = invalidation_state_map_[*it].version;
     invalidation.payload = invalidation_state_map_[*it].payload;
     invalidation_map.insert(std::make_pair(*it, invalidation));
   }
 
   delegate_->OnInvalidate(invalidation_map);
 }
 
 void SyncInvalidationListener::InformRegistrationStatus(
       invalidation::InvalidationClient* client,
       const invalidation::ObjectId& object_id,
@@ skipping 155 matching lines @@
   EmitStateChange();
 }
 
 void SyncInvalidationListener::OnIncomingNotification(
     const notifier::Notification& notification) {
   DCHECK(CalledOnValidThread());
   // Do nothing, since this is already handled by |invalidation_client_|.
 }
 
 }  // namespace syncer