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

chrome/browser/sync/engine/process_updates_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/process_updates_command.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_proto_util.h"
-#include "chrome/browser/sync/engine/syncer_session.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/engine/syncproto.h"
+#include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 
 using std::vector;
 
 namespace browser_sync {
 
+using sessions::SyncSession;
+using sessions::StatusController;
+
 ProcessUpdatesCommand::ProcessUpdatesCommand() {}
 ProcessUpdatesCommand::~ProcessUpdatesCommand() {}
 
-void ProcessUpdatesCommand::ModelChangingExecuteImpl(SyncerSession* session) {
-  syncable::ScopedDirLookup dir(session->dirman(), session->account_name());
+void ProcessUpdatesCommand::ModelChangingExecuteImpl(SyncSession* session) {
+  syncable::ScopedDirLookup dir(session->context()->directory_manager(),
+                                session->context()->account_name());
   if (!dir.good()) {
     LOG(ERROR) << "Scoped dir lookup failed!";
     return;
   }
-  SyncerStatus status(session);
 
-  const GetUpdatesResponse updates = session->update_response().get_updates();
+  const GetUpdatesResponse& updates =
+      session->status_controller()->updates_response().get_updates();
   const int update_count = updates.entries_size();
 
   LOG(INFO) << "Get updates from ts " << dir->last_sync_timestamp() <<
     " returned " << update_count << " updates.";
 
+  StatusController* status = session->status_controller();
   if (updates.has_changes_remaining()) {
     int64 changes_left = updates.changes_remaining();
     LOG(INFO) << "Changes remaining:" << changes_left;
-    status.set_num_server_changes_remaining(changes_left);
+    status->set_num_server_changes_remaining(changes_left);
   }
 
   int64 new_timestamp = 0;
   if (updates.has_new_timestamp()) {
     new_timestamp = updates.new_timestamp();
     LOG(INFO) << "Get Updates got new timestamp: " << new_timestamp;
     if (0 == update_count) {
       if (new_timestamp > dir->last_sync_timestamp()) {
         dir->set_last_sync_timestamp(new_timestamp);
-        session->set_timestamp_dirty();
+        status->set_timestamp_dirty(true);
       }
       return;
     }
   }
 
   // If we have updates that are ALL supposed to be skipped, we don't want to
   // get them again.  In fact, the account's final updates are all supposed to
   // be skipped and we DON'T step past them, we will sync forever.
   int64 latest_skip_timestamp = 0;
   bool any_non_skip_results = false;
-  vector<VerifiedUpdate>::iterator it;
-  for (it = session->VerifiedUpdatesBegin();
-       it < session->VerifiedUpdatesEnd();
+  const sessions::UpdateProgress& progress(status->update_progress());
+  vector<sessions::VerifiedUpdate>::const_iterator it;
+  for (it = progress.VerifiedUpdatesBegin();
+       it != progress.VerifiedUpdatesEnd();
        ++it) {
-    const sync_pb::SyncEntity update = it->second;
+    const sync_pb::SyncEntity& update = it->second;
 
     any_non_skip_results = (it->first != VERIFY_SKIP);
     if (!any_non_skip_results) {
       // ALL updates were to be skipped, including this one.
       if (update.sync_timestamp() > latest_skip_timestamp) {
         latest_skip_timestamp = update.sync_timestamp();
       }
     } else {
       latest_skip_timestamp = 0;
     }
@@ skipping 13 matching lines @@
         break;
     }
 
   }
 
   if (latest_skip_timestamp > new_timestamp)
     new_timestamp = latest_skip_timestamp;
 
   if (new_timestamp > dir->last_sync_timestamp()) {
     dir->set_last_sync_timestamp(new_timestamp);
-    session->set_timestamp_dirty();
+    status->set_timestamp_dirty(true);
   }
 
-  status.zero_consecutive_problem_get_updates();
-  status.zero_consecutive_errors();
-  status.set_current_sync_timestamp(dir->last_sync_timestamp());
-  status.set_syncing(true);
+  status->set_num_consecutive_problem_get_updates(0);
+  status->set_num_consecutive_errors(0);
+  status->set_current_sync_timestamp(dir->last_sync_timestamp());
+  status->set_syncing(true);
   return;
 }
 
 namespace {
 // Returns true if the entry is still ok to process.
 bool ReverifyEntry(syncable::WriteTransaction* trans, const SyncEntity& entry,
                    syncable::MutableEntry* same_id) {
 
   const bool deleted = entry.has_deleted() && entry.deleted();
   const bool is_directory = entry.IsFolder();
@@ skipping 38 matching lines @@
       !update_entry.Get(IS_UNSYNCED)) {
       // Previously this was a big issue but at this point we don't really care
       // that much if things don't match up exactly.
       LOG_IF(ERROR, !SyncerUtil::ServerAndLocalEntriesMatch(&update_entry))
           << update_entry;
   }
   return SUCCESS_PROCESSED;
 }
 
 }  // namespace browser_sync