Experimental functionize patch

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/build_commit_command.h"
 #include "sync/engine/get_commit_ids_command.h"
 #include "sync/engine/process_commit_response_command.h"
@@ skipping 45 matching lines @@
 // The OrderedCommitSet parameter is an output parameter which will contain
 // the set of all items which are to be committed.  The number of items in
 // the set shall not exceed the maximum batch size.  (The default batch size
 // is currently 25, though it can be overwritten by the server.)
 //
 // The ClientToServerMessage parameter is an output parameter which will contain
 // the commit message which should be sent to the server.  It is valid iff the
 // return value of this function is true.
 bool PrepareCommitMessage(
     sessions::SyncSession* session,
+    ModelTypeSet requested_types,
     sessions::OrderedCommitSet* commit_set,
     sync_pb::ClientToServerMessage* commit_message,
     ExtensionsActivityMonitor::Records* extensions_activity_buffer) {
   TRACE_EVENT0("sync", "PrepareCommitMessage");
 
   commit_set->Clear();
   commit_message->Clear();
 
   WriteTransaction trans(FROM_HERE, SYNCER, session->context()->directory());
 
   // Fetch the items to commit.
   const size_t batch_size = session->context()->max_commit_batch_size();
-  GetCommitIdsCommand get_commit_ids_command(&trans, batch_size, commit_set);
+  GetCommitIdsCommand get_commit_ids_command(&trans,
+                                             requested_types,
+                                             batch_size,
+                                             commit_set);
   get_commit_ids_command.Execute(session);
 
   DVLOG(1) << "Commit message will contain " << commit_set->Size() << " items.";
   if (commit_set->Empty()) {
     return false;
   }
 
   // Serialize the message.
   BuildCommitCommand build_commit_command(&trans,
                                           *commit_set,
                                           commit_message,
                                           extensions_activity_buffer);
   build_commit_command.Execute(session);
 
   SetSyncingBits(&trans, *commit_set);
   return true;
 }
 
-SyncerError BuildAndPostCommitsImpl(Syncer* syncer,
+SyncerError BuildAndPostCommitsImpl(ModelTypeSet requested_types,
+                                    Syncer* syncer,
                                     sessions::SyncSession* session,
                                     sessions::OrderedCommitSet* commit_set) {
   while (!syncer->ExitRequested()) {
     sync_pb::ClientToServerMessage commit_message;
     ExtensionsActivityMonitor::Records extensions_activity_buffer;
 
     if (!PrepareCommitMessage(session,
+                              requested_types,
                               commit_set,
                               &commit_message,
                               &extensions_activity_buffer)) {
       break;
     }
 
     sync_pb::ClientToServerResponse commit_response;
 
     DVLOG(1) << "Sending commit message.";
     TRACE_EVENT_BEGIN0("sync", "PostCommit");
@@ skipping 43 matching lines @@
     }
     session->SendEventNotification(SyncEngineEvent::STATUS_CHANGED);
   }
 
   return SYNCER_OK;
 }
 
 }  // namespace
 
 
-SyncerError BuildAndPostCommits(Syncer* syncer,
+SyncerError BuildAndPostCommits(ModelTypeSet requested_types,
+                                Syncer* syncer,
                                 sessions::SyncSession* session) {
   sessions::OrderedCommitSet commit_set(session->context()->routing_info());
-  SyncerError result = BuildAndPostCommitsImpl(syncer, session, &commit_set);
+  SyncerError result =
+      BuildAndPostCommitsImpl(requested_types, syncer, session, &commit_set);
   if (result != SYNCER_OK) {
     ClearSyncingBits(session->context()->directory(), commit_set);
   }
   return result;
 }
 
 }  // namespace syncer