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"
 #include "base/hash_tables.h"
 #include "base/location.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/bookmark_change_processor.h"
 #include "content/public/browser/browser_thread.h"
 #include "sync/api/sync_error.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
+#include "sync/syncable/write_transaction.h"
 #include "sync/util/cryptographer.h"
 #include "sync/util/data_type_histogram.h"
 
 using content::BrowserThread;
 
 namespace browser_sync {
 
 // The sync protocol identifies top-level entities by means of well-known tags,
 // which should not be confused with titles.  Each tag corresponds to a
 // singleton instance of a particular top-level node in a user's share; the
@@ skipping 485 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 = syncer::syncable::kInvalidTransactionVersion;
+  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();
+
+  BookmarkChangeProcessor::UpdateTransactionVersion(new_version,
+                                                    bookmark_model_,
+                                                    bnodes);
 }
 
 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