Experimental functionize patch

sync/engine/get_commit_ids_command.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/get_commit_ids_command.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 10 matching lines @@
 using std::vector;
 
 namespace syncer {
 
 using sessions::OrderedCommitSet;
 using sessions::SyncSession;
 using sessions::StatusController;
 
 GetCommitIdsCommand::GetCommitIdsCommand(
     syncable::BaseTransaction* trans,
+    ModelTypeSet requested_types,
     const size_t commit_batch_size,
     sessions::OrderedCommitSet* commit_set)
     : trans_(trans),
+      requested_types_(requested_types),
       requested_commit_batch_size_(commit_batch_size),
       commit_set_(commit_set) {
 }
 
 GetCommitIdsCommand::~GetCommitIdsCommand() {}
 
 SyncerError GetCommitIdsCommand::ExecuteImpl(SyncSession* session) {
   // Gather the full set of unsynced items and store it in the session. They
   // are not in the correct order for commit.
   std::set<int64> ready_unsynced_set;
   syncable::Directory::Metahandles all_unsynced_handles;
   GetUnsyncedEntries(trans_,
                      &all_unsynced_handles);
 
   ModelTypeSet encrypted_types;
   bool passphrase_missing = false;
   Cryptographer* cryptographer =
       session->context()->
       directory()->GetCryptographer(trans_);
   if (cryptographer) {
     encrypted_types = session->context()->directory()->GetNigoriHandler()->
         GetEncryptedTypes(trans_);
     passphrase_missing = cryptographer->has_pending_keys();
   };
 
-  // If we're comitting, then we must be performing a nudge job and must have a
-  // session with a nudge tracker.
-  DCHECK(session->nudge_tracker());
-
   // We filter out all unready entries from the set of unsynced handles. This
-  // new set of ready and unsynced items (which excludes throttled items as
-  // well) is then what we use to determine what is a candidate for commit.
+  // new set of ready and unsynced items is then what we use to determine what
+  // is a candidate for commit.  The caller of this SyncerCommand is responsible
+  // for ensuring that no throttled types are included among the
+  // requested_types.
   FilterUnreadyEntries(trans_,
-                       session->nudge_tracker()->GetThrottledTypes(),
+                       requested_types_,
                        encrypted_types,
                        passphrase_missing,
                        all_unsynced_handles,
                        &ready_unsynced_set);
 
   BuildCommitIds(trans_,
                  session->context()->routing_info(),
                  ready_unsynced_set);
 
   const vector<syncable::Id>& verified_commit_ids =
@@ skipping 22 matching lines @@
   return false;
 }
 
 // An entry is not considered ready for commit if any are true:
 // 1. It's in conflict.
 // 2. It requires encryption (either the type is encrypted but a passphrase
 //    is missing from the cryptographer, or the entry itself wasn't properly
 //    encrypted).
 // 3. It's type is currently throttled.
 // 4. It's a delete but has not been committed.
-bool IsEntryReadyForCommit(ModelTypeSet throttled_types,
+bool IsEntryReadyForCommit(ModelTypeSet requested_types,
                            ModelTypeSet encrypted_types,
                            bool passphrase_missing,
                            const syncable::Entry& entry) {
   DCHECK(entry.Get(syncable::IS_UNSYNCED));
   if (IsEntryInConflict(entry))
     return false;
 
   const ModelType type = entry.GetModelType();
   // We special case the nigori node because even though it is considered an
   // "encrypted type", not all nigori node changes require valid encryption
   // (ex: sync_tabs).
   if ((type != NIGORI) && encrypted_types.Has(type) &&
       (passphrase_missing ||
        syncable::EntryNeedsEncryption(encrypted_types, entry))) {
     // This entry requires encryption but is not properly encrypted (possibly
     // due to the cryptographer not being initialized or the user hasn't
     // provided the most recent passphrase).
     DVLOG(1) << "Excluding entry from commit due to lack of encryption "
              << entry;
     return false;
   }
 
-  // Look at the throttled types.
-  if (throttled_types.Has(type))
+  // Ignore it if it's not in our set of requested types.
+  if (!requested_types.Has(type))
     return false;
 
   if (entry.Get(syncable::IS_DEL) && !entry.Get(syncable::ID).ServerKnows()) {
     // New clients (following the resolution of crbug.com/125381) should not
     // create such items.  Old clients may have left some in the database
     // (crbug.com/132905), but we should now be cleaning them on startup.
     NOTREACHED() << "Found deleted and unsynced local item: " << entry;
     return false;
   }
 
@@ skipping 12 matching lines @@
   }
 
   DVLOG(2) << "Entry is ready for commit: " << entry;
   return true;
 }
 
 }  // namespace
 
 void GetCommitIdsCommand::FilterUnreadyEntries(
     syncable::BaseTransaction* trans,
-    ModelTypeSet throttled_types,
+    ModelTypeSet requested_types,
     ModelTypeSet encrypted_types,
     bool passphrase_missing,
     const syncable::Directory::Metahandles& unsynced_handles,
     std::set<int64>* ready_unsynced_set) {
   for (syncable::Directory::Metahandles::const_iterator iter =
        unsynced_handles.begin(); iter != unsynced_handles.end(); ++iter) {
     syncable::Entry entry(trans, syncable::GET_BY_HANDLE, *iter);
-    if (IsEntryReadyForCommit(throttled_types,
+    if (IsEntryReadyForCommit(requested_types,
                               encrypted_types,
                               passphrase_missing,
                               entry)) {
       ready_unsynced_set->insert(*iter);
     }
   }
 }
 
 bool GetCommitIdsCommand::AddUncommittedParentsAndTheirPredecessors(
     syncable::BaseTransaction* trans,
@@ skipping 239 matching lines @@
   // delete trees.
 
   // Add moves and creates, and prepend their uncommitted parents.
   AddCreatesAndMoves(trans, routes, ready_unsynced_set);
 
   // Add all deletes.
   AddDeletes(trans, ready_unsynced_set);
 }
 
 }  // namespace syncer