[Sync] Add plumbing of context from client to server

sync/engine/directory_commit_contribution.cc

 // Copyright 2014 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/engine/directory_commit_contribution.h"
 
 #include "sync/engine/commit_util.h"
 #include "sync/engine/get_commit_ids.h"
 #include "sync/engine/syncer_util.h"
 #include "sync/syncable/model_neutral_mutable_entry.h"
@@ skipping 24 matching lines @@
   google::protobuf::RepeatedPtrField<sync_pb::SyncEntity> entities;
   for (std::vector<int64>::iterator it = metahandles.begin();
        it != metahandles.end(); ++it) {
     sync_pb::SyncEntity* entity = entities.Add();
     syncable::ModelNeutralMutableEntry entry(&trans, GET_BY_HANDLE, *it);
     commit_util::BuildCommitItem(entry, entity);
     entry.PutSyncing(true);
   }
 
   return scoped_ptr<DirectoryCommitContribution>(
-      new DirectoryCommitContribution(metahandles, entities, dir));
+      new DirectoryCommitContribution(type, metahandles, entities, dir));
 }
 
 void DirectoryCommitContribution::AddToCommitMessage(
     sync_pb::ClientToServerMessage* msg) {
   DCHECK(syncing_bits_set_);
   sync_pb::CommitMessage* commit_message = msg->mutable_commit();
   entries_start_index_ = commit_message->entries_size();
   std::copy(entities_.begin(),
             entities_.end(),
             RepeatedPtrFieldBackInserter(commit_message->mutable_entries()));
+  sync_pb::DataTypeContext context;

[rlarocque, 2014/04/03 17:31:58]

The entities were grabbed out of the directory while a transaction was active in
the Build() function.  Would it make more sense to grab this state at that time,
too, so that we know they're in sync?

[Nicolas Zea, 2014/04/03 22:56:47]

Done.

+  dir_->GetDataTypeContext(type_, &context);
+  if (!context.context().empty())
+    commit_message->add_client_contexts()->Swap(&context);
 }
 
 SyncerError DirectoryCommitContribution::ProcessCommitResponse(
     const sync_pb::ClientToServerResponse& response,
     sessions::StatusController* status) {
   DCHECK(syncing_bits_set_);
   const sync_pb::CommitResponse& commit_response = response.commit();
 
   int transient_error_commits = 0;
   int conflicting_commits = 0;
@@ skipping 69 matching lines @@
 void DirectoryCommitContribution::CleanUp() {
   DCHECK(syncing_bits_set_);
   UnsetSyncingBits();
 }
 
 size_t DirectoryCommitContribution::GetNumEntries() const {
   return metahandles_.size();
 }
 
 DirectoryCommitContribution::DirectoryCommitContribution(
+    ModelType type,
     const std::vector<int64>& metahandles,
     const google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>& entities,
     syncable::Directory* dir)
   : dir_(dir),
+    type_(type),
     metahandles_(metahandles),
     entities_(entities),
     entries_start_index_(0xDEADBEEF),
     syncing_bits_set_(true) {
 }
 
 void DirectoryCommitContribution::UnsetSyncingBits() {
   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
   for (std::vector<int64>::const_iterator it = metahandles_.begin();
        it != metahandles_.end(); ++it) {
     syncable::ModelNeutralMutableEntry entry(&trans, GET_BY_HANDLE, *it);
     entry.PutSyncing(false);
   }
   syncing_bits_set_ = false;
 }
 
 }  // namespace syncer