sync: Follow-up to conflict resolution refactor

sync/engine/sync_scheduler_impl.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/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/auto_reset.h"
@@ skipping 94 matching lines @@
   return "";
 }
 
 GetUpdatesCallerInfo::GetUpdatesSource GetUpdatesFromNudgeSource(
     NudgeSource source) {
   switch (source) {
     case NUDGE_SOURCE_NOTIFICATION:
       return GetUpdatesCallerInfo::NOTIFICATION;
     case NUDGE_SOURCE_LOCAL:
       return GetUpdatesCallerInfo::LOCAL;
-    case NUDGE_SOURCE_CONTINUATION:
-      return GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION;
     case NUDGE_SOURCE_LOCAL_REFRESH:
       return GetUpdatesCallerInfo::DATATYPE_REFRESH;
     case NUDGE_SOURCE_UNKNOWN:
       return GetUpdatesCallerInfo::UNKNOWN;
     default:
       NOTREACHED();
       return GetUpdatesCallerInfo::UNKNOWN;
   }
 }
 
@@ skipping 629 matching lines @@
             << ": " << GetDecisionString(decision);
   if (decision != CONTINUE) {
     if (decision == SAVE) {
       HandleSaveJobDecision(job.Pass());
     } else {
       DCHECK_EQ(decision, DROP);
     }
     return false;
   }
 
-  SDVLOG(2) << "DoSyncSessionJob with "
+  SDVLOG(2) << "Calling SyncShare with "
             << SyncSessionJob::GetPurposeString(job->purpose()) << " job";
-
-  bool has_more_to_sync = true;
-  bool premature_exit = false;
-  while (DecideOnJob(*job) == CONTINUE && has_more_to_sync) {
-    SDVLOG(2) << "Calling SyncShare.";
-    // Synchronously perform the sync session from this thread.
-    premature_exit = !syncer_->SyncShare(job->mutable_session(),
-                                         job->start_step(),
-                                         job->end_step());
-
-    has_more_to_sync = job->session()->HasMoreToSync();
-    if (has_more_to_sync)
-      job->mutable_session()->PrepareForAnotherSyncCycle();
-  }
-  SDVLOG(2) << "Done SyncShare looping.";
+  bool premature_exit = !syncer_->SyncShare(job->mutable_session(),
+                                            job->start_step(),
+                                            job->end_step());
+  SDVLOG(2) << "Done SyncShare, returned: " << premature_exit;
 
   return FinishSyncSessionJob(job.Pass(), premature_exit);
 }
 
 void SyncSchedulerImpl::UpdateNudgeTimeRecords(const SyncSourceInfo& info) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
   // We are interested in recording time between local nudges for datatypes.
   // TODO(tim): Consider tracking LOCAL_NOTIFICATION as well.
   if (info.updates_source != GetUpdatesCallerInfo::LOCAL)
@@ skipping 38 matching lines @@
   }
 
   SDVLOG(2) << "Updating the next polling time after SyncMain";
   ScheduleNextSync(job.Pass(), succeeded);
   return succeeded;
 }
 
 void SyncSchedulerImpl::ScheduleNextSync(
     scoped_ptr<SyncSessionJob> finished_job, bool succeeded) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  DCHECK(!finished_job->session()->HasMoreToSync());
 
   AdjustPolling(finished_job.get());
 
   if (succeeded) {
     // Only reset backoff if we actually reached the server.
     // It's possible that we reached the server on one attempt, then had an
     // error on the next (or didn't perform some of the server-communicating
     // commands). We want to verify that, for all commands attempted, we
     // successfully spoke with the server. Therefore, we verify no errors
     // and at least one SYNCER_OK.
@@ skipping 326 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer