Refactor ModelTypePayloadMap and ObjectIdPayloadMap to StateMaps.

sync/sessions/sync_session.cc

 // Copyright (c) 2012 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/sessions/sync_session.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
@@ skipping 30 matching lines @@
       }
       // All enabled groups should have a corresponding worker.
       DCHECK(std::includes(
           groups_with_workers.begin(), groups_with_workers.end(),
           enabled_groups.begin(), enabled_groups.end()));
     }
   }
   return enabled_groups;
 }
 
-void PurgeStalePayload(ModelTypePayloadMap* original,
-                       const ModelSafeRoutingInfo& routing_info) {
-  std::vector<ModelTypePayloadMap::iterator> iterators_to_delete;
-  for (ModelTypePayloadMap::iterator i = original->begin();
+void PurgeStaleStates(ModelTypeStateMap* original,
+                      const ModelSafeRoutingInfo& routing_info) {
+  std::vector<ModelTypeStateMap::iterator> iterators_to_delete;
+  for (ModelTypeStateMap::iterator i = original->begin();
        i != original->end(); ++i) {
     if (routing_info.end() == routing_info.find(i->first)) {
       iterators_to_delete.push_back(i);
     }
   }
 
-  for (std::vector<ModelTypePayloadMap::iterator>::iterator
+  for (std::vector<ModelTypeStateMap::iterator>::iterator
        it = iterators_to_delete.begin(); it != iterators_to_delete.end();
        ++it) {
     original->erase(*it);
   }
 }
 
 }  // namesepace
 
 SyncSession::SyncSession(SyncSessionContext* context, Delegate* delegate,
     const SyncSourceInfo& source,
@@ skipping 13 matching lines @@
 
 SyncSession::~SyncSession() {}
 
 void SyncSession::Coalesce(const SyncSession& session) {
   if (context_ != session.context() || delegate_ != session.delegate_) {
     NOTREACHED();
     return;
   }
 
   // When we coalesce sessions, the sync update source gets overwritten with the
-  // most recent, while the type/payload map gets merged.
-  CoalescePayloads(&source_.types, session.source_.types);
+  // most recent, while the type/state map gets merged.
+  CoalesceStates(&source_.types, session.source_.types);
   source_.updates_source = session.source_.updates_source;
 
   std::vector<ModelSafeWorker*> temp;
   std::set_union(workers_.begin(), workers_.end(),
                  session.workers_.begin(), session.workers_.end(),
                  std::back_inserter(temp));
   workers_.swap(temp);
 
   // We have to update the model safe routing info to the union. In case the
   // same key is present in both pick the one from session.
@@ skipping 18 matching lines @@
        ++it) {
     if (routing_info_.find(it->first) != routing_info_.end()) {
       temp_routing_info[it->first] = it->second;
     }
   }
 
   // Now swap it.
   routing_info_.swap(temp_routing_info);
 
   // Now update the payload map.
-  PurgeStalePayload(&source_.types, session.routing_info_);
+  PurgeStaleStates(&source_.types, session.routing_info_);
 
   // Now update the workers.
   std::vector<ModelSafeWorker*> temp;
   std::set_intersection(workers_.begin(), workers_.end(),
                  session.workers_.begin(), session.workers_.end(),
                  std::back_inserter(temp));
   workers_.swap(temp);
 
   // Now update enabled groups.
   enabled_groups_ = ComputeEnabledGroups(routing_info_, workers_);
 }
 
 void SyncSession::PrepareForAnotherSyncCycle() {
   finished_ = false;
   source_.updates_source =
       sync_pb::GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION;
   status_controller_.reset(new StatusController(routing_info_));
 }
 
 SyncSessionSnapshot SyncSession::TakeSnapshot() const {
   syncable::Directory* dir = context_->directory();
 
   bool is_share_useable = true;
   ModelTypeSet initial_sync_ended;
-  ModelTypePayloadMap download_progress_markers;
+  ModelTypeStateMap download_progress_markers;
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     ModelType type(ModelTypeFromInt(i));
     if (routing_info_.count(type) != 0) {
       if (dir->initial_sync_ended_for_type(type))
         initial_sync_ended.Put(type);
       else
         is_share_useable = false;
     }
-    dir->GetDownloadProgressAsString(type, &download_progress_markers[type]);
+    // TODO(dcheng): Is this correct? I'm guessing GetDownloadProgressAsString()
+    // shouldn't care about the ack handle...
+    dir->GetDownloadProgressAsString(type,
+                                     &download_progress_markers[type].payload);
   }
 
   return SyncSessionSnapshot(
       status_controller_->model_neutral_state(),
       is_share_useable,
       initial_sync_ended,
       download_progress_markers,
       HasMoreToSync(),
       delegate_->IsSyncingCurrentlySilenced(),
       status_controller_->TotalNumEncryptionConflictingItems(),
@@ skipping 84 matching lines @@
   // with the server. Therefore, we verify no errors and at least one SYNCER_OK.
   return reached_server && !HadErrors(state);
 }
 
 void SyncSession::SetFinished() {
   finished_ = true;
 }
 
 }  // namespace sessions
 }  // namespace syncer