[Sync] Minor refactor around SyncCycle and ModelTypeSet usage.

components/sync/engine_impl/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 "components/sync/engine_impl/get_updates_processor.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 72 matching lines @@
     }
 
     it->second.push_back(&update);
   }
 }
 
 // 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,
+    const 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));
   }
 }
 
 void PartitionContextMutationsByType(
     const sync_pb::GetUpdatesResponse& gu_response,
-    ModelTypeSet request_types,
+    const 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 49 matching lines @@
   sync_pb::ClientToServerMessage message;
   InitDownloadUpdatesContext(cycle, create_mobile_bookmarks_folder, &message);
   PrepareGetUpdates(*request_types, &message);
 
   SyncerError result = ExecuteDownloadUpdates(request_types, cycle, &message);
   cycle->mutable_status_controller()->set_last_download_updates_result(result);
   return result;
 }
 
 void GetUpdatesProcessor::PrepareGetUpdates(
-    ModelTypeSet gu_types,
+    const ModelTypeSet& gu_types,
     sync_pb::ClientToServerMessage* message) {
   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);
@@ skipping 75 matching lines @@
                                          process_result);
   cycle->SendProtocolEvent(response_event);
 
   DVLOG(1) << "GetUpdates result: " << process_result;
 
   return process_result;
 }
 
 SyncerError GetUpdatesProcessor::ProcessResponse(
     const sync_pb::GetUpdatesResponse& gu_response,
-    ModelTypeSet request_types,
+    const ModelTypeSet& request_types,
     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;
   }
 
   SyncerError result =
       ProcessGetUpdatesResponse(request_types, gu_response, status);
   if (result != SYNCER_OK)
     return result;
 
   if (gu_response.changes_remaining() == 0) {
     return SYNCER_OK;
   } else {
     return SERVER_MORE_TO_DOWNLOAD;
   }
 }
 
 SyncerError GetUpdatesProcessor::ProcessGetUpdatesResponse(
-    ModelTypeSet gu_types,
+    const ModelTypeSet& gu_types,
     const sync_pb::GetUpdatesResponse& gu_response,
     StatusController* status_controller) {
   TypeSyncEntityMap updates_by_type;
   PartitionUpdatesByType(gu_response, gu_types, &updates_by_type);
   DCHECK_EQ(gu_types.Size(), updates_by_type.size());
 
   TypeToIndexMap progress_index_by_type;
   PartitionProgressMarkersByType(gu_response, gu_types,
                                  &progress_index_by_type);
   if (gu_types.Size() != progress_index_by_type.size()) {
@@ skipping 34 matching lines @@
                     << "Type is: " << ModelTypeToString(type);
       continue;
     }
   }
   DCHECK(progress_marker_iter == progress_index_by_type.end() &&
          updates_iter == updates_by_type.end());
 
   return SYNCER_OK;
 }
 
-void GetUpdatesProcessor::ApplyUpdates(ModelTypeSet gu_types,
+void GetUpdatesProcessor::ApplyUpdates(const ModelTypeSet& gu_types,
                                        StatusController* status_controller) {
   status_controller->set_get_updates_request_types(gu_types);
   delegate_.ApplyUpdates(gu_types, status_controller, update_handler_map_);
 }
 
 void GetUpdatesProcessor::CopyClientDebugInfo(
     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