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

sync/syncable/write_transaction.h

 // 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.
 
 #ifndef SYNC_SYNCABLE_WRITE_TRANSACTION_H_
 #define SYNC_SYNCABLE_WRITE_TRANSACTION_H_
 
 #include "sync/syncable/base_transaction.h"
 #include "sync/syncable/entry_kernel.h"
 
 namespace syncer {
 namespace syncable {
 
 // Locks db in constructor, unlocks in destructor.
 class WriteTransaction : public BaseTransaction {
  public:
   WriteTransaction(const tracked_objects::Location& from_here,
                    WriterTag writer, Directory* directory);
 
+  // Constructor used for getting back model version after making sync
+  // API changes to one model. During destruction, |new_model_version| stores
+  // the new model version if model is changed, or -1 if model is not changed.

[tim (not reviewing), 2012/11/08 17:38:49]

Note that we don't technically scope a write transaction to a specific data
type, see crbug.com/36049.  If you're doing all the work to track which types
were seen, though, we're getting closer to being able to pass that in as well. 
What are the cases where you have multiple real model types 'seen', as per your
calculations in the cc file?

[haitaol1, 2012/11/08 19:06:53]

If the transaction is for processing syncer changes, there will be multiple
datat types, I think.

On 2012/11/08 17:38:49, timsteele wrote:

+  WriteTransaction(const tracked_objects::Location& from_here,
+                   Directory* directory, int64* new_model_version);
+
   virtual ~WriteTransaction();
 
   void SaveOriginal(const EntryKernel* entry);
 
  protected:
   // Overridden by tests.
   virtual void NotifyTransactionComplete(ModelTypeSet models_with_changes);
 
  private:
   friend class MutableEntry;
 
   // Clears |mutations_|.
   ImmutableEntryKernelMutationMap RecordMutations();
 
   void UnlockAndNotify(const ImmutableEntryKernelMutationMap& mutations);
 
   ModelTypeSet NotifyTransactionChangingAndEnding(
       const ImmutableEntryKernelMutationMap& mutations);
 
+  // Increment versions of the models whose entries are modified and set the
+  // version on the changed entries.
+  void UpdateTransactionVersion(const std::vector<int64>& entry_changed);
+
   // Only the original fields are filled in until |RecordMutations()|.
   // We use a mutation map instead of a kernel set to avoid copying.
   EntryKernelMutationMap mutations_;
 
+  // Not owned.

[tim (not reviewing), 2012/11/08 17:38:49]

Can you explain more what this is for?  Why is it called model version vs
transaction version (or just version)?

[haitaol1, 2012/11/08 19:06:53]

Done. transaction_version seems better than model version since the version is
set on changed nodes besides model.

+  int64* new_model_version_;
+
   DISALLOW_COPY_AND_ASSIGN(WriteTransaction);
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif //  SYNC_SYNCABLE_WRITE_TRANSACTION_H_