sync: Introduce ModelTypeRegistry and helpers

sync/engine/commit.cc

 // Copyright 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/engine/commit.h"
 
 #include "base/debug/trace_event.h"
+#include "sync/engine/commit_processor.h"
 #include "sync/engine/commit_util.h"
 #include "sync/engine/sync_directory_commit_contribution.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/sessions/sync_session.h"
 
 namespace syncer {
 
 Commit::Commit(
     const std::map<ModelType, SyncDirectoryCommitContribution*>& contributions,
     const sync_pb::ClientToServerMessage& message,
     ExtensionsActivity::Records extensions_activity_buffer)
   : contributions_(contributions),
     deleter_(&contributions_),
     message_(message),
     extensions_activity_buffer_(extensions_activity_buffer),
     cleaned_up_(false) {
 }
 
 Commit::~Commit() {
   DCHECK(cleaned_up_);
 }
 
 Commit* Commit::Init(
     ModelTypeSet requested_types,
+    ModelTypeSet enabled_types,
     size_t max_entries,
     const std::string& account_name,
     const std::string& cache_guid,
-    CommitContributorMap* contributor_map,
+    CommitProcessor* commit_processor,
     ExtensionsActivity* extensions_activity) {
   // Gather per-type contributions.
   ContributionMap contributions;
-  size_t num_entries = 0;
-  for (ModelTypeSet::Iterator it = requested_types.First();
-       it.Good(); it.Inc()) {
-    CommitContributorMap::iterator cm_it = contributor_map->find(it.Get());
-    if (cm_it == contributor_map->end()) {
-      NOTREACHED()
-          << "Could not find requested type " << ModelTypeToString(it.Get())
-          << " in contributor map.";
-      continue;
-    }
-    size_t spaces_remaining = max_entries - num_entries;
-    SyncDirectoryCommitContribution* contribution =
-        cm_it->second->GetContribution(spaces_remaining);
-    if (contribution) {
-      num_entries += contribution->GetNumEntries();
-      contributions.insert(std::make_pair(it.Get(), contribution));
-    }
-    if (num_entries == max_entries) {
-      break;  // No point in continuting to iterate in this case.
-    }
-  }
+  commit_processor->GatherCommitContributions(
+      requested_types,
+      max_entries,
+      &contributions);
 
   // Give up if no one had anything to commit.
   if (contributions.empty())
     return NULL;
 
   sync_pb::ClientToServerMessage message;
   message.set_message_contents(sync_pb::ClientToServerMessage::COMMIT);
   message.set_share(account_name);
 
   sync_pb::CommitMessage* commit_message = message.mutable_commit();
   commit_message->set_cache_guid(cache_guid);
 
   // Set extensions activity if bookmark commits are present.
   ExtensionsActivity::Records extensions_activity_buffer;
   ContributionMap::iterator it = contributions.find(syncer::BOOKMARKS);
   if (it != contributions.end() && it->second->GetNumEntries() != 0) {
     commit_util::AddExtensionsActivityToMessage(
         extensions_activity,
         &extensions_activity_buffer,
         commit_message);
   }
 
   // Set the client config params.
-  ModelTypeSet enabled_types;
-  for (CommitContributorMap::iterator it = contributor_map->begin();
-       it != contributor_map->end(); ++it) {
-    enabled_types.Put(it->first);
-  }
-  commit_util::AddClientConfigParamsToMessage(enabled_types,
-                                                    commit_message);
+  commit_util::AddClientConfigParamsToMessage(
+      enabled_types,
+      commit_message);
 
   // Finally, serialize all our contributions.
   for (std::map<ModelType, SyncDirectoryCommitContribution*>::iterator it =
            contributions.begin(); it != contributions.end(); ++it) {
     it->second->AddToCommitMessage(&message);
   }
 
   // If we made it this far, then we've successfully prepared a commit message.
   return new Commit(contributions, message, extensions_activity_buffer);
 }
@@ skipping 70 matching lines @@
 
 void Commit::CleanUp() {
   for (ContributionMap::iterator it = contributions_.begin();
        it != contributions_.end(); ++it) {
     it->second->CleanUp();
   }
   cleaned_up_ = true;
 }
 
 }  // namespace syncer