Populate versions on individual nodes in sync model and native bookmark model.

sync/syncable/write_transaction.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/syncable/write_transaction.h"
 
 #include "sync/syncable/directory.h"
 #include "sync/syncable/directory_change_delegate.h"
+#include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/transaction_observer.h"
 #include "sync/syncable/write_transaction_info.h"
 
 namespace syncer {
 namespace syncable {
 
 WriteTransaction::WriteTransaction(const tracked_objects::Location& location,
                                    WriterTag writer, Directory* directory)
     : BaseTransaction(location, "WriteTransaction", writer, directory) {
   Lock();
@@ skipping 56 matching lines @@
   DCHECK(!mutations.Get().empty());
 
   WriteTransactionInfo write_transaction_info(
       directory_->kernel_->next_write_transaction_id,
       from_here_, writer_, mutations);
   ++directory_->kernel_->next_write_transaction_id;
 
   ImmutableWriteTransactionInfo immutable_write_transaction_info(
       &write_transaction_info);
   DirectoryChangeDelegate* const delegate = directory_->kernel_->delegate;
+  std::vector<int64> entry_changed;
   if (writer_ == syncable::SYNCAPI) {
     delegate->HandleCalculateChangesChangeEventFromSyncApi(
-        immutable_write_transaction_info, this);
+        immutable_write_transaction_info, this, &entry_changed);
   } else {
     delegate->HandleCalculateChangesChangeEventFromSyncer(
-        immutable_write_transaction_info, this);
+        immutable_write_transaction_info, this, &entry_changed);
   }
+  UpdateTransactionVersion(entry_changed);
 
   ModelTypeSet models_with_changes =
       delegate->HandleTransactionEndingChangeEvent(
           immutable_write_transaction_info, this);
 
   directory_->kernel_->transaction_observer.Call(FROM_HERE,
       &TransactionObserver::OnTransactionWrite,
       immutable_write_transaction_info, models_with_changes);
 
   return models_with_changes;
 }
 
 void WriteTransaction::NotifyTransactionComplete(
     ModelTypeSet models_with_changes) {
   directory_->kernel_->delegate->HandleTransactionCompleteChangeEvent(
       models_with_changes);
 }
 
+void WriteTransaction::UpdateTransactionVersion(
+    const std::vector<int64>& entry_changed) {
+  syncer::ModelTypeSet type_seen;
+  for (uint32 i = 0; i < entry_changed.size(); ++i) {
+    MutableEntry entry(this, GET_BY_HANDLE, entry_changed[i]);
+    if (entry.good()) {
+      ModelType type = GetModelTypeFromSpecifics(entry.Get(SPECIFICS));
+      if (!type_seen.Has(type)) {
+        directory_->IncrementTransactionVersion(type);
+        type_seen.Put(type);
+      }
+      entry.Put(TRANSACTION_VERSION, directory_->GetTransactionVersion(type));
+    }
+  }
+}
+
 WriteTransaction::~WriteTransaction() {
   const ImmutableEntryKernelMutationMap& mutations = RecordMutations();
   directory()->CheckInvariantsOnTransactionClose(this, mutations.Get());
 
   // |CheckTreeInvariants| could have thrown an unrecoverable error.
   if (unrecoverable_error_set_) {
     HandleUnrecoverableErrorIfSet();
     Unlock();
     return;
   }
@@ skipping 14 matching lines @@
     ENUM_CASE(SYNCAPI);
   };
   NOTREACHED();
   return "";
 }
 
 #undef ENUM_CASE
 
 }  // namespace syncable
 }  // namespace syncer