Refactor following sync commit loop change

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 774 matching lines @@
     C.Put(NON_UNIQUE_NAME, kEncryptedString);
     MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(D.good());
     D.Put(SPECIFICS, encrypted_bookmark);
     D.Put(NON_UNIQUE_NAME, kEncryptedString);
   }
   SyncShareNudge();
   {
     const StatusController& status_controller = session_->status_controller();
     // Expect success.
-    EXPECT_EQ(status_controller.last_post_commit_result(), SYNCER_OK);
+    EXPECT_EQ(status_controller.error().commit_result, SYNCER_OK);
     // None should be unsynced anymore.
     ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, false, false, 0, 21, 21, ids_, &rtrans);
     VERIFY_ENTRY(2, false, false, false, 0, 11, 11, ids_, &rtrans);
     VERIFY_ENTRY(3, false, false, false, 0, 11, 11, ids_, &rtrans);
     VERIFY_ENTRY(4, false, false, false, 0, 11, 11, ids_, &rtrans);
   }
 }
 
 TEST_F(SyncerTest, EncryptionAwareConflicts) {
@@ skipping 140 matching lines @@
   {
     ReadTransaction rtrans(FROM_HERE, directory());
     // Resolve the pending keys.
     cryptographer(&rtrans)->DecryptPendingKeys(key_params);
   }
   // First cycle resolves conflicts, second cycle commits changes.
   SyncShareNudge();
   EXPECT_EQ(2, status().syncer_status().num_server_overwrites);
   EXPECT_EQ(1, status().syncer_status().num_local_overwrites);
   // We successfully commited item(s).
-  EXPECT_EQ(status().last_post_commit_result(), SYNCER_OK);
+  EXPECT_EQ(status().error().commit_result, SYNCER_OK);
   SyncShareNudge();
 
   // Everything should be resolved now. The local changes should have
   // overwritten the server changes for 2 and 4, while the server changes
   // overwrote the local for entry 3.
   EXPECT_EQ(0, status().syncer_status().num_server_overwrites);
   EXPECT_EQ(0, status().syncer_status().num_local_overwrites);
-  EXPECT_EQ(status().last_post_commit_result(), SYNCER_OK);
+  EXPECT_EQ(status().error().commit_result, SYNCER_OK);
   ReadTransaction rtrans(FROM_HERE, directory());
   VERIFY_ENTRY(1, false, false, false, 0, 41, 41, ids_, &rtrans);
   VERIFY_ENTRY(2, false, false, false, 1, 31, 31, ids_, &rtrans);
   VERIFY_ENTRY(3, false, false, false, 1, 30, 30, ids_, &rtrans);
   VERIFY_ENTRY(4, false, false, false, 0, 31, 31, ids_, &rtrans);
 }
 
 #undef VERIFY_ENTRY
 
 // Receive an old nigori with old encryption keys and encrypted types. We should
@@ skipping 1746 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().error().last_post_commit_result);
+            session_->status_controller().error().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;
   uint32 items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
   {
@@ skipping 2080 matching lines @@
 
 TEST_F(SyncerPositionTiebreakingTest, MidLowHigh) {
   Add(mid_id_);
   Add(low_id_);
   Add(high_id_);
   SyncShareNudge();
   ExpectLocalOrderIsByServerId();
 }
 
 }  // namespace browser_sync