sync: Loop committing items without downloading updates (v2)

sync/engine/build_commit_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/build_commit_command.h"
 
 #include <limits>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/string_util.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
+#include "sync/sessions/ordered_commit_set.h"
 #include "sync/sessions/sync_session.h"
+#include "sync/syncable/syncable_changes_version.h"
 #include "sync/syncable/syncable.h"
-#include "sync/syncable/syncable_changes_version.h"
 #include "sync/util/time.h"
 
 using std::set;
 using std::string;
 using std::vector;
 using syncable::Entry;
 using syncable::IS_DEL;
 using syncable::SERVER_POSITION_IN_PARENT;
 using syncable::IS_UNAPPLIED_UPDATE;
 using syncable::IS_UNSYNCED;
@@ skipping 14 matching lines @@
 // static
 int64 BuildCommitCommand::GetLastPosition() {
   return std::numeric_limits<int64>::max();
 }
 
 // static
 int64 BuildCommitCommand::GetGap() {
   return 1LL << 20;
 }
 
-BuildCommitCommand::BuildCommitCommand() {}
+BuildCommitCommand::BuildCommitCommand(
+    const sessions::OrderedCommitSet& batch_commit_set,
+    ClientToServerMessage* commit_message)
+  : batch_commit_set_(batch_commit_set), commit_message_(commit_message) {
+}
+
 BuildCommitCommand::~BuildCommitCommand() {}
 
 void BuildCommitCommand::AddExtensionsActivityToMessage(
     SyncSession* session, CommitMessage* message) {
   // We only send ExtensionsActivity to the server if bookmarks are being
   // committed.
   ExtensionsActivityMonitor* monitor = session->context()->extensions_monitor();
-  if (!session->status_controller().HasBookmarkCommitActivity()) {
-    // Return the records to the activity monitor.
-    monitor->PutRecords(session->extensions_activity());
-    session->mutable_extensions_activity()->clear();
-    return;
-  }
-  const ExtensionsActivityMonitor::Records& records =
-      session->extensions_activity();
-  for (ExtensionsActivityMonitor::Records::const_iterator it = records.begin();
-       it != records.end(); ++it) {
-    sync_pb::ChromiumExtensionsActivity* activity_message =
-        message->add_extensions_activity();
-    activity_message->set_extension_id(it->second.extension_id);
-    activity_message->set_bookmark_writes_since_last_commit(
-        it->second.bookmark_write_count);
+  if (batch_commit_set_.HasBookmarkCommitId()) {
+    // This isn't perfect, since the set of extensions activity may not
+    // correlate exactly with the items being committed.  That's OK as
+    // long as we're looking for a rough estimate of extensions activity,
+    // not an precise mapping of which commits were triggered by which
+    // extension.
+    //
+    // We will push this list of extensions activity back into the
+    // ExtensionsActivityMonitor if this commit fails.  That's why we must keep
+    // a copy of these records in the session.
+    monitor->GetAndClearRecords(session->mutable_extensions_activity());
+
+    const ExtensionsActivityMonitor::Records& records =
+        session->extensions_activity();
+    for (ExtensionsActivityMonitor::Records::const_iterator it =
+         records.begin();
+         it != records.end(); ++it) {
+      sync_pb::ChromiumExtensionsActivity* activity_message =
+          message->add_extensions_activity();
+      activity_message->set_extension_id(it->second.extension_id);
+      activity_message->set_bookmark_writes_since_last_commit(
+          it->second.bookmark_write_count);
+    }
   }
 }
 
 namespace {
 void SetEntrySpecifics(MutableEntry* meta_entry, SyncEntity* sync_entry) {
   // Add the new style extension and the folder bit.
   sync_entry->mutable_specifics()->CopyFrom(meta_entry->Get(SPECIFICS));
   sync_entry->set_folder(meta_entry->Get(syncable::IS_DIR));
 
   DCHECK(meta_entry->GetModelType() == sync_entry->GetModelType());
 }
 }  // namespace
 
 SyncerError BuildCommitCommand::ExecuteImpl(SyncSession* session) {
-  ClientToServerMessage message;
-  message.set_share(session->context()->account_name());
-  message.set_message_contents(ClientToServerMessage::COMMIT);
+  commit_message_->set_share(session->context()->account_name());
+  commit_message_->set_message_contents(ClientToServerMessage::COMMIT);
 
-  CommitMessage* commit_message = message.mutable_commit();
+  CommitMessage* commit_message = commit_message_->mutable_commit();
   commit_message->set_cache_guid(
       session->write_transaction()->directory()->cache_guid());
   AddExtensionsActivityToMessage(session, commit_message);
   SyncerProtoUtil::AddRequestBirthday(
-      session->write_transaction()->directory(), &message);
+      session->write_transaction()->directory(), commit_message_);
 
   // Cache previously computed position values.  Because |commit_ids|
   // is already in sibling order, we should always hit this map after
   // the first sibling in a consecutive run of commit items.  The
   // entries in this map are (low, high) values describing the
   // space of positions that are immediate successors of the item
   // whose ID is the map's key.
   std::map<Id, std::pair<int64, int64> > position_map;
 
-  const vector<Id>& commit_ids = session->status_controller().commit_ids();
-  for (size_t i = 0; i < commit_ids.size(); i++) {
-    Id id = commit_ids[i];
+  for (size_t i = 0; i < batch_commit_set_.Size(); i++) {
+    Id id = batch_commit_set_.GetCommitIdAt(i);
     SyncEntity* sync_entry =
         static_cast<SyncEntity*>(commit_message->add_entries());
     sync_entry->set_id(id);
     MutableEntry meta_entry(session->write_transaction(),
                             syncable::GET_BY_ID,
                             id);
     CHECK(meta_entry.good());
     // This is the only change we make to the entry in this function.
     meta_entry.Put(syncable::SYNCING, true);
 
@@ skipping 80 matching lines @@
         }
         position_block.first = InterpolatePosition(position_block.first,
                                                    position_block.second);
 
         position_map[id] = position_block;
         sync_entry->set_position_in_parent(position_block.first);
       }
       SetEntrySpecifics(&meta_entry, sync_entry);
     }
   }
-  session->mutable_status_controller()->
-      mutable_commit_message()->CopyFrom(message);
 
   return SYNCER_OK;
 }
 
 int64 BuildCommitCommand::FindAnchorPosition(syncable::IdField direction,
                                              const syncable::Entry& entry) {
   Id next_id = entry.Get(direction);
   while (!next_id.IsRoot()) {
     Entry next_entry(entry.trans(),
                      syncable::GET_BY_ID,
@@ skipping 23 matching lines @@
   if (delta <= static_cast<uint64>(GetGap()*2))
     return lo + (static_cast<int64>(delta) + 7) / 8;  // Interpolate.
   else if (lo == GetFirstPosition())
     return hi - GetGap();  // Extend range just before successor.
   else
     return lo + GetGap();  // Use or extend range just after predecessor.
 }
 
 
 }  // namespace browser_sync