sync: Introduce ModelTypeRegistry and helpers

sync/engine/download.cc

 // Copyright 2013 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/download.h"
 
 #include <string>
 
 #include "base/command_line.h"
-#include "sync/engine/process_updates_util.h"
-#include "sync/engine/sync_directory_update_handler.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/sessions/nudge_tracker.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/nigori_handler.h"
 #include "sync/syncable/syncable_read_transaction.h"
 
 namespace syncer {
 
 using sessions::StatusController;
@@ skipping 75 matching lines @@
   get_updates->set_create_mobile_bookmarks_folder(
       create_mobile_bookmarks_folder);
   bool need_encryption_key = ShouldRequestEncryptionKey(session->context());
   get_updates->set_need_encryption_key(need_encryption_key);
 
   // Set legacy GetUpdatesMessage.GetUpdatesCallerInfo information.
   get_updates->mutable_caller_info()->set_notifications_enabled(
       session->context()->notifications_enabled());
 }
 
-void InitDownloadUpdatesProgress(
-    ModelTypeSet proto_request_types,
-    UpdateHandlerMap* handler_map,
-    sync_pb::GetUpdatesMessage* get_updates) {
-  for (ModelTypeSet::Iterator it = proto_request_types.First();
-       it.Good(); it.Inc()) {
-    UpdateHandlerMap::iterator handler_it = handler_map->find(it.Get());
-    DCHECK(handler_it != handler_map->end());
-    sync_pb::DataTypeProgressMarker* progress_marker =
-        get_updates->add_from_progress_marker();
-    handler_it->second->GetDownloadProgress(progress_marker);
-  }
-}
-
-// Builds a map of ModelTypes to indices to progress markers in the given
-// |gu_response| message.  The map is returned in the |index_map| parameter.
-void PartitionProgressMarkersByType(
-    const sync_pb::GetUpdatesResponse& gu_response,
-    ModelTypeSet request_types,
-    TypeToIndexMap* index_map) {
-  for (int i = 0; i < gu_response.new_progress_marker_size(); ++i) {
-    int field_number = gu_response.new_progress_marker(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 progress marker for non-enabled type "
-          << ModelTypeToString(model_type);
-      continue;
-    }
-    index_map->insert(std::make_pair(model_type, i));
-  }
-}
-
-// Examines the contents of the GetUpdates response message and forwards
-// relevant data to the UpdateHandlers for processing and persisting.
-bool ProcessUpdateResponseContents(
-    const sync_pb::GetUpdatesResponse& gu_response,
-    ModelTypeSet proto_request_types,
-    UpdateHandlerMap* handler_map,
-    StatusController* status) {
-  TypeSyncEntityMap updates_by_type;
-  PartitionUpdatesByType(gu_response, proto_request_types, &updates_by_type);
-  DCHECK_EQ(proto_request_types.Size(), updates_by_type.size());
-
-  TypeToIndexMap progress_index_by_type;
-  PartitionProgressMarkersByType(gu_response,
-                                 proto_request_types,
-                                 &progress_index_by_type);
-  if (proto_request_types.Size() != progress_index_by_type.size()) {
-    NOTREACHED() << "Missing progress markers in GetUpdates response.";
-    return false;
-  }
-
-  // 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 = handler_map->find(type);
-
-    if (update_handler_iter != handler_map->end()) {
-      update_handler_iter->second->ProcessGetUpdatesResponse(
-          gu_response.new_progress_marker(progress_marker_iter->second),
-          updates_iter->second,
-          status);
-    } 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;
-}
-
 }  // namespace
 
 void BuildNormalDownloadUpdates(
     SyncSession* session,
+    GetUpdatesProcessor* get_updates_processor,
     bool create_mobile_bookmarks_folder,
     ModelTypeSet request_types,
     const sessions::NudgeTracker& nudge_tracker,
     sync_pb::ClientToServerMessage* client_to_server_message) {
   // Request updates for all requested types.
   DVLOG(1) << "Getting updates for types "
            << ModelTypeSetToString(request_types);
   DCHECK(!request_types.Empty());
 
   InitDownloadUpdatesContext(
       session,
       create_mobile_bookmarks_folder,
       client_to_server_message);
 
   BuildNormalDownloadUpdatesImpl(
       Intersection(request_types, ProtocolTypes()),
-      session->context()->update_handler_map(),
+      get_updates_processor,
       nudge_tracker,
       client_to_server_message->mutable_get_updates());
 }
 
 void BuildNormalDownloadUpdatesImpl(
     ModelTypeSet proto_request_types,
-    UpdateHandlerMap* update_handler_map,
+    GetUpdatesProcessor* get_updates_processor,
     const sessions::NudgeTracker& nudge_tracker,
     sync_pb::GetUpdatesMessage* get_updates) {
   DCHECK(!proto_request_types.Empty());
 
-  InitDownloadUpdatesProgress(
-      proto_request_types,
-      update_handler_map,
-      get_updates);
+  // Get progress markers and other data for requested types.
+  get_updates_processor->PrepareGetUpdates(proto_request_types, get_updates);
 
   // Set legacy GetUpdatesMessage.GetUpdatesCallerInfo information.
   get_updates->mutable_caller_info()->set_source(
       nudge_tracker.updates_source());
 
   // Set the new and improved version of source, too.
   get_updates->set_get_updates_origin(sync_pb::SyncEnums::GU_TRIGGER);
   get_updates->set_is_retry(
       nudge_tracker.IsRetryRequired(base::TimeTicks::Now()));
 
   // Fill in the notification hints.
   for (int i = 0; i < get_updates->from_progress_marker_size(); ++i) {
     sync_pb::DataTypeProgressMarker* progress_marker =
         get_updates->mutable_from_progress_marker(i);
     ModelType type = GetModelTypeFromSpecificsFieldNumber(
         progress_marker->data_type_id());
 
     DCHECK(!nudge_tracker.IsTypeThrottled(type))
         << "Throttled types should have been removed from the request_types.";
 
     nudge_tracker.SetLegacyNotificationHint(type, progress_marker);
     nudge_tracker.FillProtoMessage(
         type,
         progress_marker->mutable_get_update_triggers());
   }
 }
 
 void BuildDownloadUpdatesForConfigure(
     SyncSession* session,
+    GetUpdatesProcessor* get_updates_processor,
     bool create_mobile_bookmarks_folder,
     sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source,
     ModelTypeSet request_types,
     sync_pb::ClientToServerMessage* client_to_server_message) {
   // Request updates for all enabled types.
   DVLOG(1) << "Initial download for types "
            << ModelTypeSetToString(request_types);
 
   InitDownloadUpdatesContext(
       session,
       create_mobile_bookmarks_folder,
       client_to_server_message);
   BuildDownloadUpdatesForConfigureImpl(
       Intersection(request_types, ProtocolTypes()),
-      session->context()->update_handler_map(),
+      get_updates_processor,
       source,
       client_to_server_message->mutable_get_updates());
 }
 
 void BuildDownloadUpdatesForConfigureImpl(
     ModelTypeSet proto_request_types,
-    UpdateHandlerMap* update_handler_map,
+    GetUpdatesProcessor* get_updates_processor,
     sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source,
     sync_pb::GetUpdatesMessage* get_updates) {
   DCHECK(!proto_request_types.Empty());
 
-  InitDownloadUpdatesProgress(
-      proto_request_types,
-      update_handler_map,
-      get_updates);
+  // Get progress markers and other data for requested types.
+  get_updates_processor->PrepareGetUpdates(proto_request_types, get_updates);
 
   // Set legacy GetUpdatesMessage.GetUpdatesCallerInfo information.
   get_updates->mutable_caller_info()->set_source(source);
 
   // Set the new and improved version of source, too.
   sync_pb::SyncEnums::GetUpdatesOrigin origin =
       ConvertConfigureSourceToOrigin(source);
   get_updates->set_get_updates_origin(origin);
 }
 
 void BuildDownloadUpdatesForPoll(
     SyncSession* session,
+    GetUpdatesProcessor* get_updates_processor,
     bool create_mobile_bookmarks_folder,
     ModelTypeSet request_types,
     sync_pb::ClientToServerMessage* client_to_server_message) {
   DVLOG(1) << "Polling for types "
            << ModelTypeSetToString(request_types);
 
   InitDownloadUpdatesContext(
       session,
       create_mobile_bookmarks_folder,
       client_to_server_message);
   BuildDownloadUpdatesForPollImpl(
       Intersection(request_types, ProtocolTypes()),
-      session->context()->update_handler_map(),
+      get_updates_processor,
       client_to_server_message->mutable_get_updates());
 }
 
 void BuildDownloadUpdatesForPollImpl(
     ModelTypeSet proto_request_types,
-    UpdateHandlerMap* update_handler_map,
+    GetUpdatesProcessor* get_updates_processor,
     sync_pb::GetUpdatesMessage* get_updates) {
   DCHECK(!proto_request_types.Empty());
 
-  InitDownloadUpdatesProgress(
-      proto_request_types,
-      update_handler_map,
-      get_updates);
+  // Get progress markers and other data for requested types.
+  get_updates_processor->PrepareGetUpdates(proto_request_types, get_updates);
 
   // Set legacy GetUpdatesMessage.GetUpdatesCallerInfo information.
   get_updates->mutable_caller_info()->set_source(
       sync_pb::GetUpdatesCallerInfo::PERIODIC);
 
   // Set the new and improved version of source, too.
   get_updates->set_get_updates_origin(sync_pb::SyncEnums::PERIODIC);
 }
 
 void BuildDownloadUpdatesForRetry(
     SyncSession* session,
+    GetUpdatesProcessor* get_updates_processor,
     bool create_mobile_bookmarks_folder,
     ModelTypeSet request_types,
     sync_pb::ClientToServerMessage* client_to_server_message) {
   DVLOG(1) << "Retrying for types "
            << ModelTypeSetToString(request_types);
 
   InitDownloadUpdatesContext(
       session,
       create_mobile_bookmarks_folder,
       client_to_server_message);
   BuildDownloadUpdatesForRetryImpl(
       Intersection(request_types, ProtocolTypes()),
-      session->context()->update_handler_map(),
+      get_updates_processor,
       client_to_server_message->mutable_get_updates());
 }
 
 void BuildDownloadUpdatesForRetryImpl(
     ModelTypeSet proto_request_types,
-    UpdateHandlerMap* update_handler_map,
+    GetUpdatesProcessor* get_updates_processor,
     sync_pb::GetUpdatesMessage* get_updates) {
   DCHECK(!proto_request_types.Empty());
 
-  InitDownloadUpdatesProgress(
-      proto_request_types,
-      update_handler_map,
-      get_updates);
+  get_updates_processor->PrepareGetUpdates(proto_request_types, get_updates);
 
   // Set legacy GetUpdatesMessage.GetUpdatesCallerInfo information.
   get_updates->mutable_caller_info()->set_source(
       sync_pb::GetUpdatesCallerInfo::RETRY);
 
   // Set the new and improved version of source, too.
   get_updates->set_get_updates_origin(sync_pb::SyncEnums::RETRY);
   get_updates->set_is_retry(true);
 }
 
 SyncerError ExecuteDownloadUpdates(
     ModelTypeSet request_types,
     SyncSession* session,
+    GetUpdatesProcessor* get_updates_processor,
     sync_pb::ClientToServerMessage* msg) {
   sync_pb::ClientToServerResponse update_response;
   StatusController* status = session->mutable_status_controller();
   bool need_encryption_key = ShouldRequestEncryptionKey(session->context());
 
   if (session->context()->debug_info_getter()) {
     sync_pb::DebugInfo* debug_info = msg->mutable_debug_info();
     CopyClientDebugInfo(session->context()->debug_info_getter(), debug_info);
   }
 
@@ skipping 27 matching lines @@
     syncable::Directory* dir = session->context()->directory();
     status->set_last_get_key_result(
         HandleGetEncryptionKeyResponse(update_response, dir));
   }
 
   const ModelTypeSet proto_request_types =
       Intersection(request_types, ProtocolTypes());
 
   return ProcessResponse(update_response.get_updates(),
                          proto_request_types,
-                         session->context()->update_handler_map(),
+                         get_updates_processor,
                          status);
 }
 
 SyncerError ProcessResponse(
     const sync_pb::GetUpdatesResponse& gu_response,
     ModelTypeSet proto_request_types,
-    UpdateHandlerMap* handler_map,
+    GetUpdatesProcessor* get_updates_processor,
     StatusController* status) {
   status->increment_num_updates_downloaded_by(gu_response.entries_size());
 
   // The changes remaining field is used to prevent the client from looping.  If
   // that field is being set incorrectly, we're in big trouble.
   if (!gu_response.has_changes_remaining()) {
     return SERVER_RESPONSE_VALIDATION_FAILED;
   }
   status->set_num_server_changes_remaining(gu_response.changes_remaining());
 
 
-  if (!ProcessUpdateResponseContents(gu_response,
-                                     proto_request_types,
-                                     handler_map,
-                                     status)) {
+  if (!get_updates_processor->ProcessGetUpdatesResponse(proto_request_types,
+                                                        gu_response,
+                                                        status)) {
     return SERVER_RESPONSE_VALIDATION_FAILED;
   }
 
   if (gu_response.changes_remaining() == 0) {
     return SYNCER_OK;
   } else {
     return SERVER_MORE_TO_DOWNLOAD;
   }
 }
 
 void 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 download
 
 }  // namespace syncer