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

chrome/browser/sync/glue/bookmark_model_associator.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 "chrome/browser/sync/glue/bookmark_model_associator.h"
 
 #include <stack>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 509 matching lines @@
 void BookmarkModelAssociator::PersistAssociations() {
   // If there are no dirty associations we have nothing to do. We handle this
   // explicity instead of letting the for loop do it to avoid creating a write
   // transaction in this case.
   if (dirty_associations_sync_ids_.empty()) {
     DCHECK(id_map_.empty());
     DCHECK(id_map_inverse_.empty());
     return;
   }
 
-  syncer::WriteTransaction trans(FROM_HERE, user_share_);
-  DirtyAssociationsSyncIds::iterator iter;
-  for (iter = dirty_associations_sync_ids_.begin();
-       iter != dirty_associations_sync_ids_.end();
-       ++iter) {
-    int64 sync_id = *iter;
-    syncer::WriteNode sync_node(&trans);
-    if (sync_node.InitByIdLookup(sync_id) != syncer::BaseNode::INIT_OK) {
-      unrecoverable_error_handler_->OnSingleDatatypeUnrecoverableError(
-          FROM_HERE,
-          "Could not lookup bookmark node for ID persistence.");
-      return;
+  int64 new_version = -1;
+  std::vector<const BookmarkNode*> bnodes;
+  {
+    syncer::WriteTransaction trans(FROM_HERE, user_share_, &new_version);
+    DirtyAssociationsSyncIds::iterator iter;
+    for (iter = dirty_associations_sync_ids_.begin();
+         iter != dirty_associations_sync_ids_.end();
+         ++iter) {
+      int64 sync_id = *iter;
+      syncer::WriteNode sync_node(&trans);
+      if (sync_node.InitByIdLookup(sync_id) != syncer::BaseNode::INIT_OK) {
+        unrecoverable_error_handler_->OnSingleDatatypeUnrecoverableError(
+            FROM_HERE,
+            "Could not lookup bookmark node for ID persistence.");
+        return;
+      }
+      const BookmarkNode* node = GetChromeNodeFromSyncId(sync_id);
+      if (node && sync_node.GetExternalId() != node->id()) {
+        sync_node.SetExternalId(node->id());
+        bnodes.push_back(node);
+      }
     }
-    const BookmarkNode* node = GetChromeNodeFromSyncId(sync_id);
-    if (node)
-      sync_node.SetExternalId(node->id());
-    else
-      NOTREACHED();
+    dirty_associations_sync_ids_.clear();
   }
-  dirty_associations_sync_ids_.clear();
+
+  if (new_version > 0) {
+    bookmark_model_->SetNodeMetaInfo(bookmark_model_->root_node(),
+                                     kBookmarkTransactionVersionKey,
+                                     base::Int64ToString(new_version));
+    for (uint32 i = 0; i < bnodes.size(); ++i) {

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

Prefer size_t, although I think this could all be shared with the code in
BookmarkChangeProcessor

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

Done.

+      bookmark_model_->SetNodeMetaInfo(bnodes[i],
+                                       kBookmarkTransactionVersionKey,
+                                       base::Int64ToString(new_version));
+    }
+  }
 }
 
 bool BookmarkModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   syncer::ReadTransaction trans(FROM_HERE, user_share_);
   const syncer::ModelTypeSet encrypted_types = trans.GetEncryptedTypes();
   return !encrypted_types.Has(syncer::BOOKMARKS) ||
       trans.GetCryptographer()->is_ready();
 }
 
 void BookmarkModelAssociator::CheckModelSyncState() const {
   std::string version_str;
   if (bookmark_model_->root_node()->GetMetaInfo(kBookmarkTransactionVersionKey,
                                                 &version_str)) {
     syncer::ReadTransaction trans(FROM_HERE, user_share_);
     int64 native_version;
     if (base::StringToInt64(version_str, &native_version) &&
         native_version != trans.GetModelVersion(syncer::BOOKMARKS)) {
       UMA_HISTOGRAM_ENUMERATION("Sync.LocalModelOutOfSync",
                                 syncer::BOOKMARKS, syncer::MODEL_TYPE_COUNT);
       // Clear version on bookmark model so that we only report error once.
       bookmark_model_->DeleteNodeMetaInfo(bookmark_model_->root_node(),
                                           kBookmarkTransactionVersionKey);
     }
   }
 }
 
 }  // namespace browser_sync