[Sync] Add plumbing of context from client to server

sync/engine/directory_update_handler.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_update_handler.h"
 
 #include "sync/engine/conflict_resolver.h"
 #include "sync/engine/process_updates_util.h"
 #include "sync/engine/update_applicator.h"
 #include "sync/sessions/status_controller.h"
@@ skipping 13 matching lines @@
     type_(type),
     worker_(worker) {}
 
 DirectoryUpdateHandler::~DirectoryUpdateHandler() {}
 
 void DirectoryUpdateHandler::GetDownloadProgress(
     sync_pb::DataTypeProgressMarker* progress_marker) const {
   dir_->GetDownloadProgress(type_, progress_marker);
 }
 
+void DirectoryUpdateHandler::GetDataTypeContext(
+    sync_pb::DataTypeContext* context) const {
+  dir_->GetDataTypeContext(type_, context);
+}
+
 void DirectoryUpdateHandler::ProcessGetUpdatesResponse(
     const sync_pb::DataTypeProgressMarker& progress_marker,
     const SyncEntityList& applicable_updates,
     sessions::StatusController* status) {
   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
   UpdateSyncEntities(&trans, applicable_updates, status);
 
   if (IsValidProgressMarker(progress_marker)) {
     ExpireEntriesIfNeeded(&trans, progress_marker);
     UpdateProgressMarker(progress_marker);
   }
 }
 
+void DirectoryUpdateHandler::ProcessDataTypeContextMutation(

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

Does the context need to be updated atomically with the progress markers?  If
so, then this should be merged into ProcessGetUpdatesResponse.

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

Done.

+    const sync_pb::DataTypeContext& mutated_context) {
+  sync_pb::DataTypeContext local_context;
+  dir_->GetDataTypeContext(type_, &local_context);
+
+  // Only update the local context if it is still relevant. If the local version
+  // is higher, it means a local change happened while the mutation was in
+  // flight, and the local context takes priority.
+  if (mutated_context.version() >= local_context.version()) {
+    dir_->SetDataTypeContext(type_, mutated_context);
+    // TODO(zea): trigger the datatype's UpdateDataTypeContext method.
+  }
+}
+
 void DirectoryUpdateHandler::ApplyUpdates(sessions::StatusController* status) {
   if (!IsApplyUpdatesRequired()) {
     return;
   }
 
   // This will invoke handlers that belong to the model and its thread, so we
   // switch to the appropriate thread before we start this work.
   WorkCallback c = base::Bind(
       &DirectoryUpdateHandler::ApplyUpdatesImpl,
       // We wait until the callback is executed.  We can safely use Unretained.
@@ skipping 143 matching lines @@
               new_gc_directive.version_watermark())) {
     ExpireEntriesByVersion(dir_, trans, type_,
                            new_gc_directive.version_watermark());
   }
 
   cached_gc_directive_.reset(
       new sync_pb::GarbageCollectionDirective(new_gc_directive));
 }
 
 }  // namespace syncer