[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 42 matching lines @@
            << update_response.get_updates().encryption_keys_size()
            << "encryption keys. Nigori keystore key "
            << (success ? "" : "not ") << "updated.";
   return (success ? SYNCER_OK : SERVER_RESPONSE_VALIDATION_FAILED);
 }
 
 // Given a GetUpdates response, iterates over all the returned items and
 // divides them according to their type.  Outputs a map from model types to
 // received SyncEntities.  The output map will have entries (possibly empty)
 // for all types in |requested_types|.
-void PartitionUpdatesByType(
-    const sync_pb::GetUpdatesResponse& updates,
-    ModelTypeSet requested_types,
-    TypeSyncEntityMap* updates_by_type) {
-  int update_count = updates.entries().size();
+void PartitionUpdatesByType(const sync_pb::GetUpdatesResponse& gu_response,
+                            ModelTypeSet requested_types,
+                            TypeSyncEntityMap* updates_by_type) {
+  int update_count = gu_response.entries().size();
   for (ModelTypeSet::Iterator it = requested_types.First();
        it.Good(); it.Inc()) {
     updates_by_type->insert(std::make_pair(it.Get(), SyncEntityList()));
   }
   for (int i = 0; i < update_count; ++i) {
-    const sync_pb::SyncEntity& update = updates.entries(i);
+    const sync_pb::SyncEntity& update = gu_response.entries(i);
     ModelType type = GetModelType(update);
     if (!IsRealDataType(type)) {
       NOTREACHED() << "Received update with invalid type.";
       continue;
     }
 
     TypeSyncEntityMap::iterator it = updates_by_type->find(type);
     if (it == updates_by_type->end()) {
       NOTREACHED() << "Received update for unexpected type "
                    << ModelTypeToString(type);
@@ skipping 20 matching lines @@
     if (!request_types.Has(model_type)) {
       DLOG(WARNING)
           << "Skipping unexpected progress marker for non-enabled type "
           << ModelTypeToString(model_type);
       continue;
     }
     index_map->insert(std::make_pair(model_type, i));
   }
 }
 
+void PartitionContextMutationsByType(
+    const sync_pb::GetUpdatesResponse& gu_response,
+    ModelTypeSet request_types,
+    TypeToIndexMap* index_map) {
+  for (int i = 0; i < gu_response.context_mutations_size(); ++i) {
+    int field_number = gu_response.context_mutations(i).data_type_id();
+    ModelType model_type = GetModelTypeFromSpecificsFieldNumber(field_number);
+    if (!IsRealDataType(model_type)) {
+      DLOG(WARNING) << "Unknown field number " << field_number;
+      continue;
+    }
+    if (!request_types.Has(model_type)) {
+      DLOG(WARNING)
+          << "Skipping unexpected context mutation for non-enabled type "
+          << ModelTypeToString(model_type);
+      continue;
+    }
+    index_map->insert(std::make_pair(model_type, i));
+  }
+}
+
 // Initializes the parts of the GetUpdatesMessage that depend on shared state,
 // like the ShouldRequestEncryptionKey() status.  This is kept separate from the
 // other of the message-building functions to make the rest of the code easier
 // to test.
 void InitDownloadUpdatesContext(
     sessions::SyncSession* session,
     bool create_mobile_bookmarks_folder,
     sync_pb::ClientToServerMessage* message) {
   message->set_share(session->context()->account_name());
   message->set_message_contents(sync_pb::ClientToServerMessage::GET_UPDATES);
@@ skipping 47 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 87 matching lines @@
 
   TypeToIndexMap progress_index_by_type;
   PartitionProgressMarkersByType(gu_response,
                                  gu_types,
                                  &progress_index_by_type);
   if (gu_types.Size() != progress_index_by_type.size()) {
     NOTREACHED() << "Missing progress markers in GetUpdates response.";
     return false;
   }
 
+  TypeToIndexMap context_by_type;
+  PartitionContextMutationsByType(gu_response, gu_types, &context_by_type);
+
   // Iterate over these maps in parallel, processing updates for each type.
   TypeToIndexMap::iterator progress_marker_iter =
       progress_index_by_type.begin();
   TypeSyncEntityMap::iterator updates_iter = updates_by_type.begin();
   for (; (progress_marker_iter != progress_index_by_type.end()
            && updates_iter != updates_by_type.end());
        ++progress_marker_iter, ++updates_iter) {
     DCHECK_EQ(progress_marker_iter->first, updates_iter->first);
     ModelType type = progress_marker_iter->first;
 
     UpdateHandlerMap::iterator update_handler_iter =
         update_handler_map_->find(type);
 
+    sync_pb::DataTypeContext context;
+    TypeToIndexMap::iterator context_iter = context_by_type.find(type);
+    if (context_iter != context_by_type.end())
+      context.CopyFrom(gu_response.context_mutations(context_iter->second));
+
     if (update_handler_iter != update_handler_map_->end()) {
       update_handler_iter->second->ProcessGetUpdatesResponse(
           gu_response.new_progress_marker(progress_marker_iter->second),
+          context,
           updates_iter->second,
           status_controller);
     } 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());
 
   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