sync: make scheduling logic and job ownership more obvious.

sync/engine/syncer.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/syncer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 68 matching lines @@
 bool Syncer::ExitRequested() {
   base::AutoLock lock(early_exit_requested_lock_);
   return early_exit_requested_;
 }
 
 void Syncer::RequestEarlyExit() {
   base::AutoLock lock(early_exit_requested_lock_);
   early_exit_requested_ = true;
 }
 
-void Syncer::SyncShare(sessions::SyncSession* session,
+bool Syncer::SyncShare(sessions::SyncSession* session,
                        SyncerStep first_step,
                        SyncerStep last_step) {
   ScopedSessionContextConflictResolver scoped(session->context(),
                                               &resolver_);
   session->mutable_status_controller()->UpdateStartTime();
   SyncerStep current_step = first_step;
 
   SyncerStep next_step = current_step;
   while (!ExitRequested()) {
     TRACE_EVENT1("sync", "SyncerStateMachine",
@@ skipping 112 matching lines @@
         next_step = SYNCER_END;
         break;
       }
       case SYNCER_END: {
         session->SendEventNotification(SyncEngineEvent::SYNC_CYCLE_ENDED);
         next_step = SYNCER_END;
         break;
       }
       default:
         LOG(ERROR) << "Unknown command: " << current_step;
-    }
+    }  // switch
     DVLOG(2) << "last step: " << SyncerStepToString(last_step) << ", "
              << "current step: " << SyncerStepToString(current_step) << ", "
              << "next step: " << SyncerStepToString(next_step) << ", "
              << "snapshot: " << session->TakeSnapshot().ToString();
-    if (last_step == current_step) {
-      session->SetFinished();
-      break;
-    }
+    if (last_step == current_step)
+      return true;
     current_step = next_step;
-  }
+  }  // while
+  return false;
 }
 
 void CopyServerFields(syncable::Entry* src, syncable::MutableEntry* dest) {
   dest->Put(SERVER_NON_UNIQUE_NAME, src->Get(SERVER_NON_UNIQUE_NAME));
   dest->Put(SERVER_PARENT_ID, src->Get(SERVER_PARENT_ID));
   dest->Put(SERVER_MTIME, src->Get(SERVER_MTIME));
   dest->Put(SERVER_CTIME, src->Get(SERVER_CTIME));
   dest->Put(SERVER_VERSION, src->Get(SERVER_VERSION));
   dest->Put(SERVER_IS_DIR, src->Get(SERVER_IS_DIR));
   dest->Put(SERVER_IS_DEL, src->Get(SERVER_IS_DEL));
   dest->Put(IS_UNAPPLIED_UPDATE, src->Get(IS_UNAPPLIED_UPDATE));
   dest->Put(SERVER_SPECIFICS, src->Get(SERVER_SPECIFICS));
   dest->Put(SERVER_ORDINAL_IN_PARENT, src->Get(SERVER_ORDINAL_IN_PARENT));
 }
 
 void ClearServerData(syncable::MutableEntry* entry) {
   entry->Put(SERVER_NON_UNIQUE_NAME, "");
   entry->Put(SERVER_PARENT_ID, syncable::GetNullId());
   entry->Put(SERVER_MTIME, Time());
   entry->Put(SERVER_CTIME, Time());
   entry->Put(SERVER_VERSION, 0);
   entry->Put(SERVER_IS_DIR, false);
   entry->Put(SERVER_IS_DEL, false);
   entry->Put(IS_UNAPPLIED_UPDATE, false);
   entry->Put(SERVER_SPECIFICS, sync_pb::EntitySpecifics::default_instance());
   entry->Put(SERVER_ORDINAL_IN_PARENT, Int64ToNodeOrdinal(0));
 }
 
 }  // namespace syncer