Relieve SyncerSession,SyncCycleState, SyncProcessState, SyncerSession, Syncer...

chrome/browser/sync/engine/get_commit_ids_command.cc

 // Copyright (c) 2006-2009 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 "chrome/browser/sync/engine/get_commit_ids_command.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
-#include "chrome/browser/sync/engine/syncer_session.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/util/sync_types.h"
 
 using std::set;
 using std::vector;
 
 namespace browser_sync {
 
+using sessions::SyncSession;
+using sessions::StatusController;
+
 GetCommitIdsCommand::GetCommitIdsCommand(int commit_batch_size)
     : requested_commit_batch_size_(commit_batch_size) {}
 
 GetCommitIdsCommand::~GetCommitIdsCommand() {}
 
-void GetCommitIdsCommand::ExecuteImpl(SyncerSession* session) {
+void 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.
   syncable::Directory::UnsyncedMetaHandles all_unsynced_handles;
   SyncerUtil::GetUnsyncedEntries(session->write_transaction(),
-                                     &all_unsynced_handles);
-  session->set_unsynced_handles(all_unsynced_handles);
+                                 &all_unsynced_handles);
+  StatusController* status = session->status_controller();
+  status->set_unsynced_handles(all_unsynced_handles);
 
-  BuildCommitIds(session);
+  BuildCommitIds(status->unsynced_handles(), session->write_transaction());
 
   const vector<syncable::Id>& verified_commit_ids =
       ordered_commit_set_.GetCommitIds();
 
   for (size_t i = 0; i < verified_commit_ids.size(); i++)
     LOG(INFO) << "Debug commit batch result:" << verified_commit_ids[i];
 
-  session->set_commit_ids(verified_commit_ids);
+  status->set_commit_ids(verified_commit_ids);
 }
 
 void GetCommitIdsCommand::AddUncommittedParentsAndTheirPredecessors(
     syncable::BaseTransaction* trans,
     syncable::Id parent_id) {
   using namespace syncable;
   OrderedCommitSet item_dependencies;
 
   // Climb the tree adding entries leaf -> root.
   while (!parent_id.ServerKnows()) {
@@ skipping 57 matching lines @@
   AddItemThenPredecessors(trans, item, inclusion_filter, &item_dependencies);
 
   // Reverse what we added to get the correct order.
   ordered_commit_set_.AppendReverse(item_dependencies);
 }
 
 bool GetCommitIdsCommand::IsCommitBatchFull() {
   return ordered_commit_set_.Size() >= requested_commit_batch_size_;
 }
 
-void GetCommitIdsCommand::AddCreatesAndMoves(SyncerSession* session) {
+void GetCommitIdsCommand::AddCreatesAndMoves(
+    const vector<int64>& unsynced_handles,
+    syncable::WriteTransaction* write_transaction) {
   // Add moves and creates, and prepend their uncommitted parents.
-  for (CommitMetahandleIterator iterator(session, &ordered_commit_set_);
-      !IsCommitBatchFull() && iterator.Valid();
-      iterator.Increment()) {
+  for (CommitMetahandleIterator iterator(unsynced_handles, write_transaction,
+                                         &ordered_commit_set_);
+       !IsCommitBatchFull() && iterator.Valid();
+       iterator.Increment()) {
     int64 metahandle = iterator.Current();
 
-    syncable::Entry entry(session->write_transaction(),
+    syncable::Entry entry(write_transaction,
                           syncable::GET_BY_HANDLE,
                           metahandle);
     if (!entry.Get(syncable::IS_DEL)) {
-      AddUncommittedParentsAndTheirPredecessors(
-          session->write_transaction(), entry.Get(syncable::PARENT_ID));
-      AddPredecessorsThenItem(session->write_transaction(), &entry,
-                              syncable::IS_UNSYNCED);
+      AddUncommittedParentsAndTheirPredecessors(write_transaction,
+                                                entry.Get(syncable::PARENT_ID));
+      AddPredecessorsThenItem(write_transaction, &entry, syncable::IS_UNSYNCED);
     }
   }
 
   // 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_);
 }
 
-void GetCommitIdsCommand::AddDeletes(SyncerSession* session) {
+void GetCommitIdsCommand::AddDeletes(const vector<int64>& unsynced_handles,
+    syncable::WriteTransaction* write_transaction) {
   set<syncable::Id> legal_delete_parents;
 
-  for (CommitMetahandleIterator iterator(session, &ordered_commit_set_);
-      !IsCommitBatchFull() && iterator.Valid();
-      iterator.Increment()) {
+  for (CommitMetahandleIterator iterator(unsynced_handles, write_transaction,
+                                         &ordered_commit_set_);
+       !IsCommitBatchFull() && iterator.Valid();
+       iterator.Increment()) {
     int64 metahandle = iterator.Current();
 
-    syncable::Entry entry(session->write_transaction(),
-                          syncable::GET_BY_HANDLE,
+    syncable::Entry entry(write_transaction, syncable::GET_BY_HANDLE,
                           metahandle);
 
     if (entry.Get(syncable::IS_DEL)) {
-      syncable::Entry parent(session->write_transaction(),
-                             syncable::GET_BY_ID,
+      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.
       //
       // Note: the parent could be synced if there was an update deleting a
       // folder when we had a deleted all items in it.
       // We may get more updates, or we may want to delete the entry.
       if (parent.good() &&
           parent.Get(syncable::IS_DEL) &&
           parent.Get(syncable::IS_UNSYNCED)) {
@@ skipping 31 matching lines @@
   //
   // Scan through the UnsyncedMetaHandles again. If we have a deleted
   // 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 (CommitMetahandleIterator iterator(session, &ordered_commit_set_);
+  for (CommitMetahandleIterator iterator(unsynced_handles, write_transaction,
+                                         &ordered_commit_set_);
       !IsCommitBatchFull() && iterator.Valid();
       iterator.Increment()) {
     int64 metahandle = iterator.Current();
-    syncable::MutableEntry entry(session->write_transaction(),
-                                 syncable::GET_BY_HANDLE,
+    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));
       }
     }
   }
 }
 
-void GetCommitIdsCommand::BuildCommitIds(SyncerSession* session) {
+void GetCommitIdsCommand::BuildCommitIds(const vector<int64>& unsynced_handles,
+    syncable::WriteTransaction* write_transaction) {
   // 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(session);
+  AddCreatesAndMoves(unsynced_handles, write_transaction);
 
   // Add all deletes.
-  AddDeletes(session);
+  AddDeletes(unsynced_handles, write_transaction);
 }
 
 }  // namespace browser_sync