[Sync] Add plumbing of context from client to server

sync/engine/get_updates_processor.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/get_updates_processor.h"
 
 #include <map>
 
 #include "base/debug/trace_event.h"
 #include "sync/engine/get_updates_delegate.h"
@@ skipping 160 matching lines @@
   sync_pb::GetUpdatesMessage* get_updates = message->mutable_get_updates();
 
   for (ModelTypeSet::Iterator it = gu_types.First(); it.Good(); it.Inc()) {
     UpdateHandlerMap::iterator handler_it = update_handler_map_->find(it.Get());
     DCHECK(handler_it != update_handler_map_->end())
         << "Failed to look up handler for " << ModelTypeToString(it.Get());
     sync_pb::DataTypeProgressMarker* progress_marker =
         get_updates->add_from_progress_marker();
     handler_it->second->GetDownloadProgress(progress_marker);
     progress_marker->clear_gc_directive();
+
+    sync_pb::DataTypeContext context;
+    handler_it->second->GetDataTypeContext(&context);
+    if (!context.context().empty())
+      get_updates->add_client_contexts()->Swap(&context);
   }
+
   delegate_.HelpPopulateGuMessage(get_updates);
 }
 
 SyncerError GetUpdatesProcessor::ExecuteDownloadUpdates(
     ModelTypeSet request_types,
     sessions::SyncSession* session,
     sync_pb::ClientToServerMessage* msg) {
   sync_pb::ClientToServerResponse update_response;
   sessions::StatusController* status = session->mutable_status_controller();
   bool need_encryption_key = ShouldRequestEncryptionKey(session->context());
@@ skipping 115 matching lines @@
     } else {
       DLOG(WARNING)
           << "Ignoring received updates of a type we can't handle.  "
           << "Type is: " << ModelTypeToString(type);
       continue;
     }
   }
   DCHECK(progress_marker_iter == progress_index_by_type.end() &&
          updates_iter == updates_by_type.end());
 
+  for (int i = 0; i < gu_response.context_mutations_size(); ++i) {
+    const sync_pb::DataTypeContext& context = gu_response.context_mutations(i);
+    syncer::ModelType type =
+        GetModelTypeFromSpecificsFieldNumber(context.type());
+    if (!syncer::IsRealDataType(type)) {
+      DLOG(WARNING) << "Received datatype context mutation with invalid type.";
+      continue;
+    }
+
+    UpdateHandlerMap::iterator update_handler_iter =
+        update_handler_map_->find(type);
+
+    if (update_handler_iter != update_handler_map_->end()) {
+      update_handler_iter->second->ProcessDataTypeContextMutation(context);
+    } else {
+      DLOG(WARNING)
+          << "Ignoring received context mutations of a type we can't handle.  "
+          << "Type is: " << ModelTypeToString(type);
+      continue;
+    }
+  }
+
   return true;
 }
 
 void GetUpdatesProcessor::ApplyUpdates(
     ModelTypeSet gu_types,
     sessions::StatusController* status_controller) {
   delegate_.ApplyUpdates(gu_types, status_controller, update_handler_map_);
 }
 
 void GetUpdatesProcessor::CopyClientDebugInfo(
     sessions::DebugInfoGetter* debug_info_getter,
     sync_pb::DebugInfo* debug_info) {
   DVLOG(1) << "Copying client debug info to send.";
   debug_info_getter->GetDebugInfo(debug_info);
 }
 
 }  // namespace syncer