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

sync/internal_api/sync_manager_impl.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/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 252 matching lines @@
   // We only care if the name has changed if neither specifics is encrypted
   // (encrypted nodes blow away the NON_UNIQUE_NAME).
   if (!a_specifics.has_encrypted() && !b_specifics.has_encrypted() &&
       a.ref(syncable::NON_UNIQUE_NAME) != b.ref(syncable::NON_UNIQUE_NAME))
     return true;
   if (VisiblePositionsDiffer(mutation))
     return true;
   return false;
 }
 
-bool SyncManagerImpl::ChangeBuffersAreEmpty() {
-  for (int i = 0; i < MODEL_TYPE_COUNT; ++i) {
-    if (!change_buffers_[i].IsEmpty())
-      return false;
-  }
-  return true;
-}
-
 void SyncManagerImpl::ThrowUnrecoverableError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ReadTransaction trans(FROM_HERE, GetUserShare());
   trans.GetWrappedTrans()->OnUnrecoverableError(
       FROM_HERE, "Simulating unrecoverable error for testing purposes.");
 }
 
 ModelTypeSet SyncManagerImpl::InitialSyncEndedTypes() {
   return directory()->initial_sync_ended_types();
 }
@@ skipping 476 matching lines @@
   }
 }
 
 ModelTypeSet
 SyncManagerImpl::HandleTransactionEndingChangeEvent(
     const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans) {
   // This notification happens immediately before a syncable WriteTransaction
   // falls out of scope. It happens while the channel mutex is still held,
   // and while the transaction mutex is held, so it cannot be re-entrant.
-  if (!change_delegate_ || ChangeBuffersAreEmpty())
+  if (!change_delegate_ || change_records_.empty())
     return ModelTypeSet();
 
   // This will continue the WriteTransaction using a read only wrapper.
   // This is the last chance for read to occur in the WriteTransaction
   // that's closing. This special ReadTransaction will not close the
   // underlying transaction.
   ReadTransaction read_trans(GetUserShare(), trans);
 
   ModelTypeSet models_with_changes;
-  for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
-    const ModelType type = ModelTypeFromInt(i);
-    if (change_buffers_[type].IsEmpty())
-      continue;
-
-    ImmutableChangeRecordList ordered_changes;
-    // TODO(akalin): Propagate up the error further (see
-    // http://crbug.com/100907).
-    CHECK(change_buffers_[type].GetAllChangesInTreeOrder(&read_trans,
-                                                         &ordered_changes));
-    if (!ordered_changes.Get().empty()) {
-      // Increment transaction version so that change processor can read
-      // updated value and set it in native model after changes are applied.
-      trans->directory()->IncrementTransactionVersion(type);
-
-      change_delegate_->
-          OnChangesApplied(type,
-                           trans->directory()->GetTransactionVersion(type),
-                           &read_trans, ordered_changes);
-      change_observer_.Call(FROM_HERE,
-          &SyncManager::ChangeObserver::OnChangesApplied,
-          type, write_transaction_info.Get().id, ordered_changes);
-      models_with_changes.Put(type);
-    }
-    change_buffers_[i].Clear();
+  for (ChangeRecordMap::const_iterator it = change_records_.begin();
+      it != change_records_.end(); ++it) {
+    DCHECK(!it->second.Get().empty());
+    ModelType type = ModelTypeFromInt(it->first);
+    change_delegate_->
+        OnChangesApplied(type, trans->directory()->GetTransactionVersion(type),
+                         &read_trans, it->second);
+    change_observer_.Call(FROM_HERE,
+        &SyncManager::ChangeObserver::OnChangesApplied,
+        type, write_transaction_info.Get().id, it->second);
+    models_with_changes.Put(type);
   }
+  change_records_.clear();
   return models_with_changes;
 }
 
 void SyncManagerImpl::HandleCalculateChangesChangeEventFromSyncApi(
     const ImmutableWriteTransactionInfo& write_transaction_info,
-    syncable::BaseTransaction* trans) {
+    syncable::BaseTransaction* trans,
+    std::vector<int64>* entry_changed) {
   // We have been notified about a user action changing a sync model.
-  LOG_IF(WARNING, !ChangeBuffersAreEmpty()) <<
+  LOG_IF(WARNING, !change_records_.empty()) <<
       "CALCULATE_CHANGES called with unapplied old changes.";
 
   // The mutated model type, or UNSPECIFIED if nothing was mutated.
   ModelTypeSet mutated_model_types;
 
   const syncable::ImmutableEntryKernelMutationMap& mutations =
       write_transaction_info.Get().mutations;
   for (syncable::EntryKernelMutationMap::const_iterator it =
            mutations.Get().begin(); it != mutations.Get().end(); ++it) {
     if (!it->second.mutated.ref(syncable::IS_UNSYNCED)) {
       continue;
     }
 
     ModelType model_type =
         GetModelTypeFromSpecifics(it->second.mutated.ref(SPECIFICS));
     if (model_type < FIRST_REAL_MODEL_TYPE) {
       NOTREACHED() << "Permanent or underspecified item changed via syncapi.";
       continue;
     }
 
     // Found real mutation.
     if (model_type != UNSPECIFIED) {
       mutated_model_types.Put(model_type);
+      entry_changed->push_back(it->second.mutated.ref(syncable::META_HANDLE));
     }
   }
 
   // Nudge if necessary.
   if (!mutated_model_types.Empty()) {
     if (weak_handle_this_.IsInitialized()) {
       weak_handle_this_.Call(FROM_HERE,
                              &SyncManagerImpl::RequestNudgeForDataTypes,
                              FROM_HERE,
                              mutated_model_types);
@@ skipping 28 matching lines @@
         NOTREACHED();
         return;
       }
     }
     buffer->SetSpecificsForId(id, original_specifics);
   }
 }
 
 void SyncManagerImpl::HandleCalculateChangesChangeEventFromSyncer(
     const ImmutableWriteTransactionInfo& write_transaction_info,
-    syncable::BaseTransaction* trans) {
+    syncable::BaseTransaction* trans,
+    std::vector<int64> *entry_changed) {

[Nicolas Zea, 2012/11/02 21:02:25]

nit: "std::vector<int64>* entry_changed" (no space before *)

[haitaol1, 2012/11/02 22:58:18]

Done.

   // We only expect one notification per sync step, so change_buffers_ should
   // contain no pending entries.
-  LOG_IF(WARNING, !ChangeBuffersAreEmpty()) <<
+  LOG_IF(WARNING, !change_records_.empty()) <<
       "CALCULATE_CHANGES called with unapplied old changes.";
 
+  ChangeReorderBuffer change_buffers[MODEL_TYPE_COUNT];
+
   Cryptographer* crypto = directory()->GetCryptographer(trans);
   const syncable::ImmutableEntryKernelMutationMap& mutations =
       write_transaction_info.Get().mutations;
   for (syncable::EntryKernelMutationMap::const_iterator it =
            mutations.Get().begin(); it != mutations.Get().end(); ++it) {
     bool existed_before = !it->second.original.ref(syncable::IS_DEL);
     bool exists_now = !it->second.mutated.ref(syncable::IS_DEL);
 
     // Omit items that aren't associated with a model.
     ModelType type =
         GetModelTypeFromSpecifics(it->second.mutated.ref(SPECIFICS));
     if (type < FIRST_REAL_MODEL_TYPE)
       continue;
 
     int64 handle = it->first;
     if (exists_now && !existed_before)
-      change_buffers_[type].PushAddedItem(handle);
+      change_buffers[type].PushAddedItem(handle);
     else if (!exists_now && existed_before)
-      change_buffers_[type].PushDeletedItem(handle);
+      change_buffers[type].PushDeletedItem(handle);
     else if (exists_now && existed_before &&
              VisiblePropertiesDiffer(it->second, crypto)) {
-      change_buffers_[type].PushUpdatedItem(
+      change_buffers[type].PushUpdatedItem(
           handle, VisiblePositionsDiffer(it->second));
     }
 
-    SetExtraChangeRecordData(handle, type, &change_buffers_[type], crypto,
+    SetExtraChangeRecordData(handle, type, &change_buffers[type], crypto,
                              it->second.original, existed_before, exists_now);
   }
+
+  ReadTransaction read_trans(GetUserShare(), trans);
+  for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
+    if (!change_buffers[i].IsEmpty()) {
+      if (change_buffers[i].GetAllChangesInTreeOrder(&read_trans,
+                                                     &(change_records_[i]))) {
+        for (uint32 j = 0; j < change_records_[i].Get().size(); ++j)
+          entry_changed->push_back((change_records_[i].Get())[j].id);
+      }
+      if (change_records_[i].Get().empty())
+        change_records_.erase(i);
+    }
+  }
 }
 
 TimeDelta SyncManagerImpl::GetNudgeDelayTimeDelta(
     const ModelType& model_type) {
   return NudgeStrategy::GetNudgeDelayTimeDelta(model_type, this);
 }
 
 void SyncManagerImpl::RequestNudgeForDataTypes(
     const tracked_objects::Location& nudge_location,
     ModelTypeSet types) {
@@ skipping 377 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer