sync: Loop committing items without downloading updates

sync/engine/get_commit_ids_command.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/engine/get_commit_ids_command.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "sync/engine/nigori_util.h"
 #include "sync/engine/syncer_util.h"
 #include "sync/syncable/syncable.h"
 #include "sync/util/cryptographer.h"
 
 using std::set;
 using std::vector;
 
 namespace browser_sync {
 
 using sessions::OrderedCommitSet;
 using sessions::SyncSession;
 using sessions::StatusController;
 
-GetCommitIdsCommand::GetCommitIdsCommand(int commit_batch_size)
-    : requested_commit_batch_size_(commit_batch_size) {}
+GetCommitIdsCommand::GetCommitIdsCommand(
+    size_t commit_batch_size,
+    sessions::OrderedCommitSet* commit_set)
+  : 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::UnsyncedMetaHandles all_unsynced_handles;
   SyncerUtil::GetUnsyncedEntries(session->write_transaction(),
                                  &all_unsynced_handles);
@@ skipping 17 matching lines @@
                        throttled_types,
                        encrypted_types,
                        passphrase_missing,
                        all_unsynced_handles,
                        &ready_unsynced_set);
 
   BuildCommitIds(session->write_transaction(),
                  session->routing_info(),
                  ready_unsynced_set);
 
-  StatusController* status = session->mutable_status_controller();
   syncable::Directory::UnsyncedMetaHandles ready_unsynced_vector(
       ready_unsynced_set.begin(), ready_unsynced_set.end());
-  status->set_unsynced_handles(ready_unsynced_vector);
   const vector<syncable::Id>& verified_commit_ids =
-      ordered_commit_set_->GetAllCommitIds();
+      commit_set_->GetAllCommitIds();
 
   for (size_t i = 0; i < verified_commit_ids.size(); i++)
     DVLOG(1) << "Debug commit batch result:" << verified_commit_ids[i];
 
-  status->set_commit_set(*ordered_commit_set_.get());
   return SYNCER_OK;
 }
 
 namespace {
 
 bool IsEntryInConflict(const syncable::Entry& entry) {
   if (entry.Get(syncable::IS_UNSYNCED) &&
       entry.Get(syncable::SERVER_VERSION) > 0 &&
       (entry.Get(syncable::SERVER_VERSION) >
        entry.Get(syncable::BASE_VERSION))) {
@@ skipping 96 matching lines @@
     const syncable::Entry& item,
     sessions::OrderedCommitSet* result) const {
   OrderedCommitSet item_dependencies(routes);
   syncable::Id parent_id = item.Get(syncable::PARENT_ID);
 
   // Climb the tree adding entries leaf -> root.
   while (!parent_id.ServerKnows()) {
     syncable::Entry parent(trans, syncable::GET_BY_ID, parent_id);
     CHECK(parent.good()) << "Bad user-only parent in item path.";
     int64 handle = parent.Get(syncable::META_HANDLE);
-    if (ordered_commit_set_->HaveCommitItem(handle)) {
+    if (commit_set_->HaveCommitItem(handle)) {
       // We've already added this parent (and therefore all of its parents).
       // We can return early.
       break;
     }
     if (!AddItemThenPredecessors(trans, ready_unsynced_set, parent,
                                  &item_dependencies)) {
       // There was a parent/predecessor in conflict. We return without adding
-      // anything to |ordered_commit_set_|.
+      // anything to |commit_set|.
       DVLOG(1) << "Parent or parent's predecessor was in conflict, omitting "
                << item;
       return false;
     }
     parent_id = parent.Get(syncable::PARENT_ID);
   }
 
   // Reverse what we added to get the correct order.
   result->AppendReverse(item_dependencies);
   return true;
@@ skipping 17 matching lines @@
                         item.GetModelType());
   return true;
 }
 
 bool GetCommitIdsCommand::AddItemThenPredecessors(
     syncable::BaseTransaction* trans,
     const std::set<int64>& ready_unsynced_set,
     const syncable::Entry& item,
     OrderedCommitSet* result) const {
   int64 item_handle = item.Get(syncable::META_HANDLE);
-  if (ordered_commit_set_->HaveCommitItem(item_handle)) {
+  if (commit_set_->HaveCommitItem(item_handle)) {
     // We've already added this item to the commit set, and so must have
     // already added the predecessors as well.
     return true;
   }
   if (!AddItem(ready_unsynced_set, item, result))
     return false;  // Item is in conflict.
   if (item.Get(syncable::IS_DEL))
     return true;  // Deleted items have no predecessors.
 
   syncable::Id prev_id = item.Get(syncable::PREV_ID);
   while (!prev_id.IsRoot()) {
     syncable::Entry prev(trans, syncable::GET_BY_ID, prev_id);
     CHECK(prev.good()) << "Bad id when walking predecessors.";
     if (!prev.Get(syncable::IS_UNSYNCED))
       break;
     int64 handle = prev.Get(syncable::META_HANDLE);
-    if (ordered_commit_set_->HaveCommitItem(handle)) {
+    if (commit_set_->HaveCommitItem(handle)) {
       // We've already added this item to the commit set, and so must have
       // already added the predecessors as well.
       return true;
     }
     if (!AddItem(ready_unsynced_set, prev, result))
       return false;  // Item is in conflict.
     prev_id = prev.Get(syncable::PREV_ID);
   }
   return true;
 }
@@ skipping 12 matching lines @@
     DVLOG(1) << "Predecessor was in conflict, omitting " << item;
     return false;
   }
 
   // Reverse what we added to get the correct order.
   result->AppendReverse(item_dependencies);
   return true;
 }
 
 bool GetCommitIdsCommand::IsCommitBatchFull() const {
-  return ordered_commit_set_->Size() >= requested_commit_batch_size_;
+  return commit_set_->Size() >= requested_commit_batch_size_;
 }
 
 void GetCommitIdsCommand::AddCreatesAndMoves(
     syncable::WriteTransaction* write_transaction,
     const ModelSafeRoutingInfo& routes,
     const std::set<int64>& ready_unsynced_set) {
   // Add moves and creates, and prepend their uncommitted parents.
   for (std::set<int64>::const_iterator iter = ready_unsynced_set.begin();
        !IsCommitBatchFull() && iter != ready_unsynced_set.end(); ++iter) {
     int64 metahandle = *iter;
-    if (ordered_commit_set_->HaveCommitItem(metahandle))
+    if (commit_set_->HaveCommitItem(metahandle))
       continue;
 
     syncable::Entry entry(write_transaction,
                           syncable::GET_BY_HANDLE,
                           metahandle);
     if (!entry.Get(syncable::IS_DEL)) {
       // We only commit an item + its dependencies if it and all its
       // dependencies are not in conflict.
       OrderedCommitSet item_dependencies(routes);
       if (AddUncommittedParentsAndTheirPredecessors(
               write_transaction,
               routes,
               ready_unsynced_set,
               entry,
               &item_dependencies) &&
           AddPredecessorsThenItem(write_transaction,
                                   routes,
                                   ready_unsynced_set,
                                   entry,
                                   &item_dependencies)) {
-        ordered_commit_set_->Append(item_dependencies);
+        commit_set_->Append(item_dependencies);
       }
     }
   }
 
   // It's possible that we overcommitted while trying to expand dependent
   // items.  If so, truncate the set down to the allowed size.
-  ordered_commit_set_->Truncate(requested_commit_batch_size_);
+  commit_set_->Truncate(requested_commit_batch_size_);
 }
 
 void GetCommitIdsCommand::AddDeletes(
     syncable::WriteTransaction* write_transaction,
     const std::set<int64>& ready_unsynced_set) {
   set<syncable::Id> legal_delete_parents;
 
   for (std::set<int64>::const_iterator iter = ready_unsynced_set.begin();
        !IsCommitBatchFull() && iter != ready_unsynced_set.end(); ++iter) {
     int64 metahandle = *iter;
-    if (ordered_commit_set_->HaveCommitItem(metahandle))
+    if (commit_set_->HaveCommitItem(metahandle))
       continue;
 
     syncable::Entry entry(write_transaction, syncable::GET_BY_HANDLE,
                           metahandle);
 
     if (entry.Get(syncable::IS_DEL)) {
       syncable::Entry parent(write_transaction, syncable::GET_BY_ID,
                              entry.Get(syncable::PARENT_ID));
       // If the parent is deleted and unsynced, then any children of that
       // parent don't need to be added to the delete queue.
@@ skipping 10 matching lines @@
         // then we'll miss it in the roll up. We have to add it in manually.
         // TODO(chron): Unit test for move / delete cases:
         // Case 1: Locally moved, then parent deleted
         // Case 2: Server moved, then locally issue recursive delete.
         if (entry.Get(syncable::ID).ServerKnows() &&
             entry.Get(syncable::PARENT_ID) !=
                 entry.Get(syncable::SERVER_PARENT_ID)) {
           DVLOG(1) << "Inserting moved and deleted entry, will be missed by "
                    << "delete roll." << entry.Get(syncable::ID);
 
-          ordered_commit_set_->AddCommitItem(metahandle,
+          commit_set_->AddCommitItem(metahandle,
               entry.Get(syncable::ID),
               entry.GetModelType());
         }
 
         // Skip this entry since it's a child of a parent that will be
         // deleted. The server will unroll the delete and delete the
         // child as well.
         continue;
       }
 
@@ skipping 10 matching lines @@
   // entry, then check if the parent is in legal_delete_parents.
   //
   // Parent being in legal_delete_parents means for the child:
   //   a recursive delete is not currently happening (no recent deletes in same
   //     folder)
   //   parent did expect at least one old deleted child
   //   parent was not deleted
   for (std::set<int64>::const_iterator iter = ready_unsynced_set.begin();
        !IsCommitBatchFull() && iter != ready_unsynced_set.end(); ++iter) {
     int64 metahandle = *iter;
-    if (ordered_commit_set_->HaveCommitItem(metahandle))
+    if (commit_set_->HaveCommitItem(metahandle))
       continue;
     syncable::MutableEntry entry(write_transaction, syncable::GET_BY_HANDLE,
                                  metahandle);
     if (entry.Get(syncable::IS_DEL)) {
       syncable::Id parent_id = entry.Get(syncable::PARENT_ID);
       if (legal_delete_parents.count(parent_id)) {
-        ordered_commit_set_->AddCommitItem(metahandle, entry.Get(syncable::ID),
+        commit_set_->AddCommitItem(metahandle, entry.Get(syncable::ID),
             entry.GetModelType());
       }
     }
   }
 }
 
 void GetCommitIdsCommand::BuildCommitIds(
     syncable::WriteTransaction* write_transaction,
     const ModelSafeRoutingInfo& routes,
     const std::set<int64>& ready_unsynced_set) {
-  ordered_commit_set_.reset(new OrderedCommitSet(routes));
   // Commits follow these rules:
   // 1. Moves or creates are preceded by needed folder creates, from
   //    root to leaf.  For folders whose contents are ordered, moves
   //    and creates appear in order.
   // 2. Moves/Creates before deletes.
   // 3. Deletes, collapsed.
   // We commit deleted moves under deleted items as moves when collapsing
   // delete trees.
 
   // Add moves and creates, and prepend their uncommitted parents.
   AddCreatesAndMoves(write_transaction, routes, ready_unsynced_set);
 
   // Add all deletes.
   AddDeletes(write_transaction, ready_unsynced_set);
 }
 
 }  // namespace browser_sync