sync: make scheduling logic and job ownership more obvious.

sync/engine/syncer_unittest.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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <algorithm>
 #include <limits>
 #include <list>
@@ skipping 167 matching lines @@
     GetModelSafeRoutingInfo(&info);
     GetWorkers(&workers);
     ModelTypeInvalidationMap invalidation_map =
         ModelSafeRoutingInfoToInvalidationMap(info, std::string());
     return new SyncSession(context_.get(), this,
         sessions::SyncSourceInfo(sync_pb::GetUpdatesCallerInfo::UNKNOWN,
                                  invalidation_map),
         info, workers);
   }
 
-  bool SyncShareAsDelegate(
-      SyncSchedulerImpl::SyncSessionJob::SyncSessionJobPurpose purpose) {
+  bool SyncShareAsDelegate(SyncSessionJob::Purpose purpose) {
     SyncerStep start;
     SyncerStep end;
-    SyncSchedulerImpl::SetSyncerStepsForPurpose(purpose, &start, &end);
+    SyncSessionJob::GetSyncerStepsForPurpose(purpose, &start, &end);
 
     session_.reset(MakeSession());
-    syncer_->SyncShare(session_.get(), start, end);
+    EXPECT_TRUE(syncer_->SyncShare(session_.get(), start, end));
     return session_->HasMoreToSync();
   }
 
   bool SyncShareNudge() {
     session_.reset(MakeSession());
-    return SyncShareAsDelegate(SyncSchedulerImpl::SyncSessionJob::NUDGE);
+    return SyncShareAsDelegate(SyncSessionJob::NUDGE);
   }
 
   bool SyncShareConfigure() {
     session_.reset(MakeSession());
-    return SyncShareAsDelegate(
-        SyncSchedulerImpl::SyncSessionJob::CONFIGURATION);
+    return SyncShareAsDelegate(SyncSessionJob::CONFIGURATION);
   }
 
   void LoopSyncShare() {
     bool should_loop = false;
     int loop_iterations = 0;
     do {
       ASSERT_LT(++loop_iterations, 100) << "infinite loop detected. please fix";
       should_loop = SyncShareNudge();
     } while (should_loop);
   }
@@ skipping 2289 matching lines @@
     }
   }
   ASSERT_EQ(items_to_commit, directory()->unsynced_entity_count());
 
   // The second commit should fail.  It will be preceded by one successful
   // GetUpdate and one succesful commit.
   mock_server_->FailNthPostBufferToPathCall(3);
   SyncShareNudge();
 
   EXPECT_EQ(1U, mock_server_->commit_messages().size());
-  EXPECT_FALSE(session_->Succeeded());
   EXPECT_EQ(SYNC_SERVER_ERROR,
             session_->status_controller().model_neutral_state().commit_result);
   EXPECT_EQ(items_to_commit - kDefaultMaxCommitBatchSize,
             directory()->unsynced_entity_count());
 }
 
 // Test that a single conflict response from the server will cause us to exit
 // the commit loop immediately.
 TEST_F(SyncerTest, CommitManyItemsInOneGo_CommitConflict) {
   uint32 num_batches = 2;
@@ skipping 10 matching lines @@
     }
   }
   ASSERT_EQ(items_to_commit, directory()->unsynced_entity_count());
 
   // Return a CONFLICT response for the first item.
   mock_server_->set_conflict_n_commits(1);
   SyncShareNudge();
 
   // We should stop looping at the first sign of trouble.
   EXPECT_EQ(1U, mock_server_->commit_messages().size());
-  EXPECT_FALSE(session_->Succeeded());
+  EXPECT_FALSE(session_->HasMoreToSync());
   EXPECT_EQ(items_to_commit - (kDefaultMaxCommitBatchSize - 1),
             directory()->unsynced_entity_count());
 }
 
 TEST_F(SyncerTest, HugeConflict) {
   int item_count = 300;  // We should be able to do 300 or 3000 w/o issue.
 
   syncable::Id parent_id = ids_.NewServerId();
   syncable::Id last_id = parent_id;
   vector<syncable::Id> tree_ids;
@@ skipping 2118 matching lines @@
 
 TEST_F(SyncerPositionTiebreakingTest, MidLowHigh) {
   Add(mid_id_);
   Add(low_id_);
   Add(high_id_);
   SyncShareNudge();
   ExpectLocalOrderIsByServerId();
 }
 
 }  // namespace syncer