Revert of [Sync] Refactoring polling to be reliable.

sync/engine/syncer_unittest.cc

 // Copyright 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 238 matching lines @@
 
   void OnActionableError(const SyncProtocolError& error) override {}
   void OnRetryTimeChanged(base::Time retry_time) override {}
   void OnThrottledTypesChanged(ModelTypeSet throttled_types) override {}
   void OnMigrationRequested(ModelTypeSet types) override {}
 
   void ResetSession() {
     session_.reset(SyncSession::Build(context_.get(), this));
   }
 
-  bool SyncShareNudge() {
+  void SyncShareNudge() {
     ResetSession();
 
     // Pretend we've seen a local change, to make the nudge_tracker look normal.
     nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS));
 
-    return syncer_->NormalSyncShare(context_->GetEnabledTypes(),
-                                         &nudge_tracker_, session_.get());
+    EXPECT_TRUE(syncer_->NormalSyncShare(context_->GetEnabledTypes(),
+                                         &nudge_tracker_, session_.get()));
   }
 
-  bool SyncShareConfigure() {
+  void SyncShareConfigure() {
     ResetSession();
-    return syncer_->ConfigureSyncShare(
+    EXPECT_TRUE(syncer_->ConfigureSyncShare(
             context_->GetEnabledTypes(),
             sync_pb::GetUpdatesCallerInfo::RECONFIGURATION,
-            session_.get());
+            session_.get()));
   }
 
   void SetUp() override {
     dir_maker_.SetUp();
     mock_server_.reset(new MockConnectionManager(directory(),
                                                  &cancelation_signal_));
     debug_info_getter_.reset(new MockDebugInfoGetter);
     EnableDatatype(BOOKMARKS);
     EnableDatatype(NIGORI);
     EnableDatatype(PREFERENCES);
@@ skipping 177 matching lines @@
             case MOVED_FROM_ROOT:
               entry.PutServerParentId(trans.root_id());
               break;
             default:
               FAIL() << "Bad value in CommitOrderingTest list";
           }
         }
         test++;
       }
     }
-    EXPECT_TRUE(SyncShareNudge());
+    SyncShareNudge();
     ASSERT_TRUE(expected_positions.size() ==
                 mock_server_->committed_ids().size());
     // If this test starts failing, be aware other sort orders could be valid.
     for (size_t i = 0; i < expected_positions.size(); ++i) {
       SCOPED_TRACE(i);
       EXPECT_EQ(1u, expected_positions.count(i));
       EXPECT_EQ(expected_positions[i], mock_server_->committed_ids()[i]);
     }
   }
 
@@ skipping 138 matching lines @@
   // regression for a very old bug.
 }
 
 TEST_F(SyncerTest, GetCommitIdsFiltersThrottledEntries) {
   const ModelTypeSet throttled_types(BOOKMARKS);
   sync_pb::EntitySpecifics bookmark_data;
   AddDefaultFieldValue(BOOKMARKS, &bookmark_data);
 
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
                                    foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutSpecifics(bookmark_data);
     A.PutNonUniqueName("bookmark");
   }
 
   // Now sync without enabling bookmarks.
   mock_server_->ExpectGetUpdatesRequestTypes(
       Difference(context_->GetEnabledTypes(), ModelTypeSet(BOOKMARKS)));
   ResetSession();
   syncer_->NormalSyncShare(
       Difference(context_->GetEnabledTypes(), ModelTypeSet(BOOKMARKS)),
       &nudge_tracker_, session_.get());
 
   {
     // Nothing should have been committed as bookmarks is throttled.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     Entry entryA(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(entryA.good());
     EXPECT_TRUE(entryA.GetIsUnsynced());
   }
 
   // Sync again with bookmarks enabled.
   mock_server_->ExpectGetUpdatesRequestTypes(context_->GetEnabledTypes());
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // It should have been committed.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     Entry entryA(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(entryA.good());
     EXPECT_FALSE(entryA.GetIsUnsynced());
   }
 }
 
 // We use a macro so we can preserve the error location.
@@ skipping 23 matching lines @@
   bookmark.mutable_bookmark()->set_title("title");
   AddDefaultFieldValue(BOOKMARKS, &encrypted_bookmark);
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10,
                                    foreign_cache_guid(), "-2");
   mock_server_->AddUpdateDirectory(3, 0, "C", 10, 10,
                                    foreign_cache_guid(), "-3");
   mock_server_->AddUpdateDirectory(4, 0, "D", 10, 10,
                                    foreign_cache_guid(), "-4");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // Server side change will put A in conflict.
   mock_server_->AddUpdateDirectory(1, 0, "A", 20, 20,
                                    foreign_cache_guid(), "-1");
   {
     // Mark bookmarks as encrypted and set the cryptographer to have pending
     // keys.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     Cryptographer other_cryptographer(&encryptor_);
     other_cryptographer.AddKey(other_params);
     sync_pb::EntitySpecifics specifics;
@@ skipping 23 matching lines @@
     ASSERT_TRUE(C.good());
     C.PutIsUnsynced(true);
     C.PutNonUniqueName(kEncryptedString);
     // Unencrypted non_unique_name.
     MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(D.good());
     D.PutIsUnsynced(true);
     D.PutSpecifics(encrypted_bookmark);
     D.PutNonUniqueName("not encrypted");
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // Nothing should have commited due to bookmarks being encrypted and
     // the cryptographer having pending keys. A would have been resolved
     // as a simple conflict, but still be unsynced until the next sync cycle.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, true, false, 0, 20, 20, ids_, &rtrans);
     VERIFY_ENTRY(2, false, true, false, 0, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(3, false, true, false, 0, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(4, false, true, false, 0, 10, 10, ids_, &rtrans);
 
     // Resolve the pending keys.
     GetCryptographer(&rtrans)->DecryptPendingKeys(other_params);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // All properly encrypted and non-conflicting items should commit. "A" was
     // conflicting, but last sync cycle resolved it as simple conflict, so on
     // this sync cycle it committed succesfullly.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     // Committed successfully.
     VERIFY_ENTRY(1, false, false, false, 0, 21, 21, ids_, &rtrans);
     // Committed successfully.
     VERIFY_ENTRY(2, false, false, false, 0, 11, 11, ids_, &rtrans);
     // Was not properly encrypted.
     VERIFY_ENTRY(3, false, true, false, 0, 10, 10, ids_, &rtrans);
     // Was not properly encrypted.
     VERIFY_ENTRY(4, false, true, false, 0, 10, 10, ids_, &rtrans);
   }
   {
     // Fix the remaining items.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry C(&wtrans, GET_BY_ID, ids_.FromNumber(3));
     ASSERT_TRUE(C.good());
     C.PutSpecifics(encrypted_bookmark);
     C.PutNonUniqueName(kEncryptedString);
     MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(D.good());
     D.PutSpecifics(encrypted_bookmark);
     D.PutNonUniqueName(kEncryptedString);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     const StatusController& status_controller = session_->status_controller();
     // Expect success.
     EXPECT_EQ(status_controller.model_neutral_state().commit_result, SYNCER_OK);
     // None should be unsynced anymore.
     syncable::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, GetUpdatesPartialThrottled) {
   sync_pb::EntitySpecifics bookmark, pref;
   bookmark.mutable_bookmark()->set_title("title");
   pref.mutable_preference()->set_name("name");
   AddDefaultFieldValue(BOOKMARKS, &bookmark);
   AddDefaultFieldValue(PREFERENCES, &pref);
 
   // Normal sync, all the data types should get synced.
   mock_server_->AddUpdateSpecifics(1, 0, "A", 10, 10, true, 0, bookmark,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateSpecifics(2, 1, "B", 10, 10, false, 2, bookmark,
                                    foreign_cache_guid(), "-2");
   mock_server_->AddUpdateSpecifics(3, 1, "C", 10, 10, false, 1, bookmark,
                                    foreign_cache_guid(), "-3");
   mock_server_->AddUpdateSpecifics(4, 0, "D", 10, 10, false, 0, pref);
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // Initial state. Everything is normal.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, false, false, 0, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(2, false, false, false, 1, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(3, false, false, false, 1, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(4, false, false, false, 0, 10, 10, ids_, &rtrans);
   }
 
   // Set BOOKMARKS throttled but PREFERENCES not,
@@ skipping 13 matching lines @@
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     MutableEntry C(&wtrans, GET_BY_ID, ids_.FromNumber(3));
     MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
     A.PutIsUnsynced(true);
     B.PutIsUnsynced(true);
     C.PutIsUnsynced(true);
     D.PutIsUnsynced(true);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // BOOKMARKS throttled.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, true, false, 0, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(2, false, true, false, 1, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(3, false, true, false, 1, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(4, false, false, false, 0, 21, 21, ids_, &rtrans);
   }
 
   // Unthrottled BOOKMARKS, then BOOKMARKS should get synced now.
   mock_server_->set_partial_throttling(false);
 
   mock_server_->AddUpdateSpecifics(1, 0, "E", 30, 30, true, 0, bookmark,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateSpecifics(2, 1, "F", 30, 30, false, 2, bookmark,
                                    foreign_cache_guid(), "-2");
   mock_server_->AddUpdateSpecifics(3, 1, "G", 30, 30, false, 1, bookmark,
                                    foreign_cache_guid(), "-3");
   mock_server_->AddUpdateSpecifics(4, 0, "H", 30, 30, false, 0, pref);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // BOOKMARKS unthrottled.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, false, false, 0, 31, 31, ids_, &rtrans);
     VERIFY_ENTRY(2, false, false, false, 1, 31, 31, ids_, &rtrans);
     VERIFY_ENTRY(3, false, false, false, 1, 31, 31, ids_, &rtrans);
     VERIFY_ENTRY(4, false, false, false, 0, 30, 30, ids_, &rtrans);
   }
 }
 
@@ skipping 134 matching lines @@
   UniquePosition pos2;
   UniquePosition pos3;
 
   mock_server_->AddUpdateSpecifics(1, 0, "A", 10, 10, true, 0, bookmark,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateSpecifics(2, 1, "B", 10, 10, false, 2, bookmark,
                                    foreign_cache_guid(), "-2");
   mock_server_->AddUpdateSpecifics(3, 1, "C", 10, 10, false, 1, bookmark,
                                    foreign_cache_guid(), "-3");
   mock_server_->AddUpdateSpecifics(4, 0, "D", 10, 10, false, 0, pref);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // Initial state. Everything is normal.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, false, false, 0, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(2, false, false, false, 1, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(3, false, false, false, 1, 10, 10, ids_, &rtrans);
     VERIFY_ENTRY(4, false, false, false, 0, 10, 10, ids_, &rtrans);
 
     Entry entry1(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(entry1.GetUniquePosition().Equals(
@@ skipping 12 matching lines @@
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateSpecifics(2, 1, kEncryptedString, 20, 20, false, 2,
                                    encrypted_bookmark,
                                    foreign_cache_guid(), "-2");
   mock_server_->AddUpdateSpecifics(3, 1, kEncryptedString, 20, 20, false, 1,
                                    encrypted_bookmark,
                                    foreign_cache_guid(), "-3");
   mock_server_->AddUpdateSpecifics(4, 0, kEncryptedString, 20, 20, false, 0,
                                    encrypted_pref,
                                    foreign_cache_guid(), "-4");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // All should be unapplied due to being undecryptable and have a valid
     // BASE_SERVER_SPECIFICS.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, true, false, true, 0, 10, 20, ids_, &rtrans);
     VERIFY_ENTRY(2, true, false, true, 1, 10, 20, ids_, &rtrans);
     VERIFY_ENTRY(3, true, false, true, 1, 10, 20, ids_, &rtrans);
     VERIFY_ENTRY(4, true, false, true, 0, 10, 20, ids_, &rtrans);
   }
 
   // Server side change that don't modify anything should not affect
   // BASE_SERVER_SPECIFICS (such as name changes and mtime changes).
   mock_server_->AddUpdateSpecifics(1, 0, kEncryptedString, 30, 30, true, 0,
                                    encrypted_bookmark,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateSpecifics(2, 1, kEncryptedString, 30, 30, false, 2,
                                    encrypted_bookmark,
                                    foreign_cache_guid(), "-2");
   // Item 3 doesn't change.
   mock_server_->AddUpdateSpecifics(4, 0, kEncryptedString, 30, 30, false, 0,
                                    encrypted_pref,
                                    foreign_cache_guid(), "-4");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // Items 1, 2, and 4 should have newer server versions, 3 remains the same.
     // All should remain unapplied due to be undecryptable.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, true, false, true, 0, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(2, true, false, true, 1, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(3, true, false, true, 1, 10, 20, ids_, &rtrans);
     VERIFY_ENTRY(4, true, false, true, 0, 10, 30, ids_, &rtrans);
   }
 
   // Positional changes, parent changes, and specifics changes should reset
   // BASE_SERVER_SPECIFICS.
   // Became unencrypted.
   mock_server_->AddUpdateSpecifics(1, 0, "A", 40, 40, true, 0, bookmark,
                                    foreign_cache_guid(), "-1");
   // Reordered to after item 2.
   mock_server_->AddUpdateSpecifics(3, 1, kEncryptedString, 30, 30, false, 3,
                                    encrypted_bookmark,
                                    foreign_cache_guid(), "-3");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // Items 2 and 4 should be the only ones with BASE_SERVER_SPECIFICS set.
     // Items 1 is now unencrypted, so should have applied normally.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, false, false, 0, 40, 40, ids_, &rtrans);
     VERIFY_ENTRY(2, true, false, true, 1, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(3, true, false, false, 1, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(4, true, false, true, 0, 10, 30, ids_, &rtrans);
   }
 
@@ skipping 14 matching lines @@
     ASSERT_TRUE(C.good());
     C.PutSpecifics(modified_bookmark);
     C.PutNonUniqueName(kEncryptedString);
     C.PutIsUnsynced(true);
     MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(D.good());
     D.PutSpecifics(modified_pref);
     D.PutNonUniqueName(kEncryptedString);
     D.PutIsUnsynced(true);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // Item 1 remains unsynced due to there being pending keys.
     // Items 2, 3, 4 should remain unsynced since they were not up to date.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, true, false, 0, 40, 40, ids_, &rtrans);
     VERIFY_ENTRY(2, true, true, true, 1, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(3, true, true, false, 1, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(4, true, true, true, 0, 10, 30, ids_, &rtrans);
   }
 
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     // Resolve the pending keys.
     GetCryptographer(&rtrans)->DecryptPendingKeys(key_params);
   }
   // First cycle resolves conflicts, second cycle commits changes.
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, GetUpdateCounters(BOOKMARKS).num_server_overwrites);
   EXPECT_EQ(1, GetUpdateCounters(PREFERENCES).num_server_overwrites);
   EXPECT_EQ(1, GetUpdateCounters(BOOKMARKS).num_local_overwrites);
 
   // We successfully commited item(s).
   EXPECT_EQ(2, GetCommitCounters(BOOKMARKS).num_commits_attempted);
   EXPECT_EQ(2, GetCommitCounters(BOOKMARKS).num_commits_success);
   EXPECT_EQ(1, GetCommitCounters(PREFERENCES).num_commits_attempted);
   EXPECT_EQ(1, GetCommitCounters(PREFERENCES).num_commits_success);
 
-  EXPECT_TRUE(SyncShareNudge());
+  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 there will be no new overwrites.
   EXPECT_EQ(1, GetUpdateCounters(BOOKMARKS).num_server_overwrites);
   EXPECT_EQ(1, GetUpdateCounters(BOOKMARKS).num_local_overwrites);
 
   EXPECT_EQ(2, GetCommitCounters(BOOKMARKS).num_commits_success);
@@ skipping 18 matching lines @@
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutBaseVersion(1);
     parent.PutId(parent_id_);
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent_id_, "Pete");
     ASSERT_TRUE(child.good());
     child.PutId(child_id_);
     child.PutBaseVersion(1);
     WriteTestDataToEntry(&wtrans, &child);
   }
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ASSERT_EQ(2u, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   {
     syncable::ReadTransaction rt(FROM_HERE, directory());
     Entry entry(&rt, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(entry.good());
     VerifyTestDataInEntry(&rt, &entry);
   }
@@ skipping 27 matching lines @@
     parent2.PutIsDir(true);
     parent2.PutSpecifics(DefaultPreferencesSpecifics());
     parent2.PutBaseVersion(1);
     parent2.PutId(pref_node_id);
   }
 
   directory()->PurgeEntriesWithTypeIn(ModelTypeSet(PREFERENCES),
                                       ModelTypeSet(),
                                       ModelTypeSet());
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ASSERT_EQ(2U, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   {
     syncable::ReadTransaction rt(FROM_HERE, directory());
     Entry entry(&rt, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(entry.good());
     VerifyTestDataInEntry(&rt, &entry);
   }
@@ skipping 17 matching lines @@
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutBaseVersion(1);
     parent.PutId(parent_id_);
   }
 
   directory()->PurgeEntriesWithTypeIn(ModelTypeSet(BOOKMARKS),
                                       ModelTypeSet(),
                                       ModelTypeSet());
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   directory()->SaveChanges();
   {
     syncable::ReadTransaction rt(FROM_HERE, directory());
     Entry entry(&rt, syncable::GET_BY_ID, parent_id_);
     ASSERT_FALSE(entry.good());
   }
 }
 
 TEST_F(SyncerTest, TestPurgeWithJournal) {
   {
@@ skipping 38 matching lines @@
     EXPECT_EQ(parent_id_, (*journal_entries.begin())->ref(syncable::ID));
     EXPECT_EQ(child_id_, (*journal_entries.rbegin())->ref(syncable::ID));
   }
 }
 
 TEST_F(SyncerTest, ResetVersions) {
   // Download some pref items.
   mock_server_->AddUpdatePref("id1", "", "tag1", 20, 20);
   mock_server_->AddUpdatePref("id2", "", "tag2", 30, 30);
   mock_server_->AddUpdatePref("id3", "", "tag3", 40, 40);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     // Modify one of the preferences locally, mark another one as unapplied,
     // and create another unsynced preference.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, GET_BY_CLIENT_TAG, "tag1");
     entry.PutIsUnsynced(true);
 
     MutableEntry entry2(&wtrans, GET_BY_CLIENT_TAG, "tag2");
     entry2.PutIsUnappliedUpdate(true);
@@ skipping 234 matching lines @@
       grandchild.PutId(ids_.FromNumber(105));
       grandchild.PutIsUnsynced(true);
       grandchild.PutIsDel(true);
       grandchild.PutIsDir(false);
       grandchild.PutSpecifics(DefaultBookmarkSpecifics());
       grandchild.PutBaseVersion(1);
       grandchild.PutMtime(now_minus_2h);
     }
   }
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ASSERT_EQ(6u, mock_server_->committed_ids().size());
   // This test will NOT unroll deletes because SERVER_PARENT_ID is not set.
   // It will treat these like moves.
   vector<syncable::Id> commit_ids(mock_server_->committed_ids());
   EXPECT_TRUE(ids_.FromNumber(100) == commit_ids[0]);
   EXPECT_TRUE(ids_.FromNumber(101) == commit_ids[1]);
   EXPECT_TRUE(ids_.FromNumber(102) == commit_ids[2]);
   // We don't guarantee the delete orders in this test, only that they occur
   // at the end.
   std::sort(commit_ids.begin() + 3, commit_ids.end());
@@ skipping 49 matching lines @@
     parent.PutId(ids_.FromNumber(-104));
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent2_id, "B");
     ASSERT_TRUE(child.good());
     child.PutIsUnsynced(true);
     child.PutIsDir(true);
     child.PutSpecifics(DefaultBookmarkSpecifics());
     child.PutId(ids_.FromNumber(105));
     child.PutBaseVersion(1);
   }
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ASSERT_EQ(6u, mock_server_->committed_ids().size());
 
   // This strange iteration and std::count() usage is to allow the order to
   // vary.  All we really care about is that parent1_id and parent2_id are the
   // first two IDs, and that the children make up the next four.  Other than
   // that, ordering doesn't matter.
 
   vector<syncable::Id>::const_iterator i =
       mock_server_->committed_ids().begin();
   vector<syncable::Id>::const_iterator parents_begin = i;
@@ skipping 33 matching lines @@
     ASSERT_TRUE(child2.good());
     child2.PutIsUnsynced(true);
     child2.PutSpecifics(DefaultBookmarkSpecifics());
     child2.PutId(child2_id);
 
     parent.PutBaseVersion(1);
     child1.PutBaseVersion(1);
     child2.PutBaseVersion(1);
   }
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ASSERT_EQ(3u, mock_server_->committed_ids().size());
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   // There are two possible valid orderings.
   if (child2_id == mock_server_->committed_ids()[1]) {
     EXPECT_TRUE(child2_id == mock_server_->committed_ids()[1]);
     EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[2]);
   } else {
     EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
     EXPECT_TRUE(child2_id == mock_server_->committed_ids()[2]);
   }
@@ skipping 31 matching lines @@
     MutableEntry child(
         &wtrans, CREATE, BOOKMARKS, parent2_id, child_name);
     ASSERT_TRUE(child.good());
     child.PutIsUnsynced(true);
     child.PutIsDir(true);
     child.PutSpecifics(DefaultBookmarkSpecifics());
     child.PutId(child_id);
     child.PutBaseVersion(1);
   }
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ASSERT_EQ(3u, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(parent2_id == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(child_id == mock_server_->committed_ids()[2]);
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     // Check that things committed correctly.
     Entry entry_1(&rtrans, syncable::GET_BY_ID, parent_id_);
     EXPECT_EQ(entry_1.GetNonUniqueName(), parent1_name);
@@ skipping 50 matching lines @@
     MutableEntry child(
         &wtrans, CREATE, BOOKMARKS, parent2_local_id, child_name);
     ASSERT_TRUE(child.good());
     child.PutIsUnsynced(true);
     child.PutIsDir(true);
     child.PutSpecifics(DefaultBookmarkSpecifics());
     child.PutId(child_local_id);
     meta_handle_b = child.GetMetahandle();
   }
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ASSERT_EQ(3u, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(parent2_local_id == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(child_local_id == mock_server_->committed_ids()[2]);
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
 
     Entry parent(&rtrans, syncable::GET_BY_ID,
                  GetOnlyEntryWithName(&rtrans, rtrans.root_id(), parent_name));
@@ skipping 17 matching lines @@
   }
 }
 
 TEST_F(SyncerTest, UpdateWithZeroLengthName) {
   // One illegal update
   mock_server_->AddUpdateDirectory(
       1, 0, std::string(), 1, 10, foreign_cache_guid(), "-1");
   // And one legal one that we're going to delete.
   mock_server_->AddUpdateDirectory(2, 0, "FOO", 1, 10,
                                    foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // Delete the legal one. The new update has a null name.
   mock_server_->AddUpdateDirectory(
       2, 0, std::string(), 2, 20, foreign_cache_guid(), "-2");
   mock_server_->SetLastUpdateDeleted();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 }
 
 TEST_F(SyncerTest, TestBasicUpdate) {
   string id = "some_id";
   string parent_id = "0";
   string name = "in_root";
   int64 version = 10;
   int64 timestamp = 10;
   mock_server_->AddUpdateDirectory(id, parent_id, name, version, timestamp,
                                    foreign_cache_guid(), "-1");
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     Entry entry(&trans, GET_BY_ID,
                syncable::Id::CreateFromServerId("some_id"));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.GetIsDir());
     EXPECT_TRUE(entry.GetServerVersion()== version);
     EXPECT_TRUE(entry.GetBaseVersion()== version);
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
@@ skipping 13 matching lines @@
                                    foreign_cache_guid(), "-2");
 
   // Unknown parent: should never be applied. "-80" is a legal server ID,
   // because any string sent by the server is a legal server ID in the sync
   // protocol, but it's not the ID of any item known to the client.  This
   // update should succeed validation, but be stuck in the unapplied state
   // until an item with the server ID "-80" arrives.
   mock_server_->AddUpdateDirectory(3, -80, "bad_parent", 10, 10,
                                    foreign_cache_guid(), "-3");
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // Id 3 should be in conflict now.
   EXPECT_EQ(
       1,
       GetUpdateCounters(BOOKMARKS).num_hierarchy_conflict_application_failures);
 
   // The only request in that loop should have been a GetUpdate.
   // At that point, we didn't know whether or not we had conflicts.
   ASSERT_TRUE(mock_server_->last_request().has_get_updates());
   VerifyHierarchyConflictsUnspecified(mock_server_->last_request());
 
   // These entries will be used in the second set of updates.
   mock_server_->AddUpdateDirectory(4, 0, "newer_version", 20, 10,
                                    foreign_cache_guid(), "-4");
   mock_server_->AddUpdateDirectory(5, 0, "circular1", 10, 10,
                                    foreign_cache_guid(), "-5");
   mock_server_->AddUpdateDirectory(6, 5, "circular2", 10, 10,
                                    foreign_cache_guid(), "-6");
   mock_server_->AddUpdateDirectory(9, 3, "bad_parent_child", 10, 10,
                                    foreign_cache_guid(), "-9");
   mock_server_->AddUpdateDirectory(100, 9, "bad_parent_child2", 10, 10,
                                    foreign_cache_guid(), "-100");
   mock_server_->AddUpdateDirectory(10, 0, "dir_to_bookmark", 10, 10,
                                    foreign_cache_guid(), "-10");
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // The three items with an unresolved parent should be unapplied (3, 9, 100).
   // The name clash should also still be in conflict.
   EXPECT_EQ(
       3,
       GetUpdateCounters(BOOKMARKS).num_hierarchy_conflict_application_failures);
 
   // This time around, we knew that there were conflicts.
   ASSERT_TRUE(mock_server_->last_request().has_get_updates());
   VerifyHierarchyConflictsReported(mock_server_->last_request());
 
@@ skipping 25 matching lines @@
   mock_server_->AddUpdateDirectory(1, 0, "new_name", 20, 20,
                                    foreign_cache_guid(), "-1");
 
   // Moving 5 under 6 will create a cycle: a conflict.
   mock_server_->AddUpdateDirectory(5, 6, "circular3", 20, 20,
                                    foreign_cache_guid(), "-5");
 
   // Flip the is_dir bit: should fail verify & be dropped.
   mock_server_->AddUpdateBookmark(10, 0, "dir_to_bookmark", 20, 20,
                                   foreign_cache_guid(), "-10");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // Version number older than last known: should fail verify & be dropped.
   mock_server_->AddUpdateDirectory(4, 0, "old_version", 10, 10,
                                    foreign_cache_guid(), "-4");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry still_a_dir(&trans, GET_BY_ID, ids_.FromNumber(10));
     ASSERT_TRUE(still_a_dir.good());
     EXPECT_FALSE(still_a_dir.GetIsUnappliedUpdate());
     EXPECT_EQ(10u, still_a_dir.GetBaseVersion());
     EXPECT_EQ(10u, still_a_dir.GetServerVersion());
     EXPECT_TRUE(still_a_dir.GetIsDir());
 
@@ skipping 100 matching lines @@
   // The following update should cause the folder to both apply the update, as
   // well as reassociate the id.
   mock_server_->AddUpdateDirectory(new_folder_id, root_id_,
       "new_folder", new_version, timestamp,
       local_cache_guid(), folder_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
   // Alright! Apply that update!
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
   {
     // The folder's ID should have been updated.
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry folder(&trans, GET_BY_HANDLE, metahandle_folder);
     ASSERT_TRUE(folder.good());
     EXPECT_EQ("new_folder", folder.GetNonUniqueName());
     EXPECT_TRUE(new_version == folder.GetBaseVersion());
     EXPECT_TRUE(new_folder_id == folder.GetId());
     EXPECT_TRUE(folder.GetId().ServerKnows());
     EXPECT_EQ(trans.root_id(), folder.GetParentId());
@@ skipping 44 matching lines @@
 
   // Generate an update from the server with a relevant ID reassignment.
   mock_server_->AddUpdateBookmark(new_entry_id, root_id_,
       "new_entry", new_version, timestamp,
       local_cache_guid(), entry_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
   // Alright! Apply that update!
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(new_version == entry.GetBaseVersion());
     EXPECT_TRUE(new_entry_id == entry.GetId());
     EXPECT_EQ("new_entry", entry.GetNonUniqueName());
   }
 }
 
@@ skipping 40 matching lines @@
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     Id new_entry_id = GetOnlyEntryWithName(
         &trans, trans.root_id(), "new_entry");
     MutableEntry entry(&trans, GET_BY_ID, new_entry_id);
     ASSERT_TRUE(entry.good());
     entry.PutIsDel(true);
   }
 
   // Just don't CHECK fail in sync, have the update split.
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Id new_entry_id = GetOnlyEntryWithName(
         &trans, trans.root_id(), "new_entry");
     Entry entry(&trans, GET_BY_ID, new_entry_id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsDel());
 
     Entry old_entry(&trans, GET_BY_ID, entry_id);
     ASSERT_TRUE(old_entry.good());
     EXPECT_TRUE(old_entry.GetIsDel());
   }
 }
 
 // TODO(chron): Add more unsanitized name tests.
 TEST_F(SyncerTest, ConflictMatchingEntryHandlesUnsanitizedNames) {
   mock_server_->AddUpdateDirectory(1, 0, "A/A", 10, 10,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateDirectory(2, 0, "B/B", 10, 10,
                                    foreign_cache_guid(), "-2");
   mock_server_->set_conflict_all_commits(true);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
 
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutIsUnappliedUpdate(true);
     A.PutServerVersion(20);
 
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.PutIsUnappliedUpdate(true);
     B.PutServerVersion(20);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   saw_syncer_event_ = false;
   mock_server_->set_conflict_all_commits(false);
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry A(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     EXPECT_TRUE(A.GetIsUnsynced()== false);
     EXPECT_TRUE(A.GetIsUnappliedUpdate()== false);
     EXPECT_TRUE(A.GetServerVersion()== 20);
 
     Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_TRUE(B.GetIsUnsynced()== false);
     EXPECT_TRUE(B.GetIsUnappliedUpdate()== false);
     EXPECT_TRUE(B.GetServerVersion()== 20);
   }
 }
 
 TEST_F(SyncerTest, ConflictMatchingEntryHandlesNormalNames) {
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10,
                                    foreign_cache_guid(), "-2");
   mock_server_->set_conflict_all_commits(true);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
 
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutIsUnappliedUpdate(true);
     A.PutServerVersion(20);
 
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.PutIsUnappliedUpdate(true);
     B.PutServerVersion(20);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   saw_syncer_event_ = false;
   mock_server_->set_conflict_all_commits(false);
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry A(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     EXPECT_TRUE(A.GetIsUnsynced()== false);
     EXPECT_TRUE(A.GetIsUnappliedUpdate()== false);
@@ skipping 11 matching lines @@
   mock_server_->AddUpdateDirectory(4, 3, "ggchild", 10, 10,
                                    foreign_cache_guid(), "-4");
   mock_server_->AddUpdateDirectory(3, 2, "gchild", 10, 10,
                                    foreign_cache_guid(), "-3");
   mock_server_->AddUpdateDirectory(5, 4, "gggchild", 10, 10,
                                    foreign_cache_guid(), "-5");
   mock_server_->AddUpdateDirectory(2, 1, "child", 10, 10,
                                    foreign_cache_guid(), "-2");
   mock_server_->AddUpdateDirectory(1, 0, "parent", 10, 10,
                                    foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   syncable::ReadTransaction trans(FROM_HERE, directory());
 
   Id child_id = GetOnlyEntryWithName(
         &trans, ids_.FromNumber(4), "gggchild");
   Entry child(&trans, GET_BY_ID, child_id);
   ASSERT_TRUE(child.good());
 }
 
 class EntryCreatedInNewFolderTest : public SyncerTest {
  public:
@@ skipping 21 matching lines @@
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "bob");
     ASSERT_TRUE(entry.good());
     entry.PutIsDir(true);
     entry.PutIsUnsynced(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
   }
 
   mock_server_->SetMidCommitCallback(
       base::Bind(&EntryCreatedInNewFolderTest::CreateFolderInBob,
                  base::Unretained(this)));
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // We loop until no unsynced handles remain, so we will commit both ids.
   EXPECT_EQ(2u, mock_server_->committed_ids().size());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry parent_entry(&trans, syncable::GET_BY_ID,
         GetOnlyEntryWithName(&trans, TestIdFactory::root(), "bob"));
     ASSERT_TRUE(parent_entry.good());
 
     Id child_id =
         GetOnlyEntryWithName(&trans, parent_entry.GetId(), "bob");
     Entry child(&trans, syncable::GET_BY_ID, child_id);
     ASSERT_TRUE(child.good());
     EXPECT_EQ(parent_entry.GetId(), child.GetParentId());
   }
 }
 
 TEST_F(SyncerTest, NegativeIDInUpdate) {
   mock_server_->AddUpdateBookmark(-10, 0, "bad", 40, 40,
                                   foreign_cache_guid(), "-100");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // The negative id would make us CHECK!
 }
 
 TEST_F(SyncerTest, UnappliedUpdateOnCreatedItemItemDoesNotCrash) {
   int64 metahandle_fred;
   syncable::Id orig_id;
   {
     // Create an item.
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry fred_match(&trans, CREATE, BOOKMARKS, trans.root_id(),
                             "fred_match");
     ASSERT_TRUE(fred_match.good());
     metahandle_fred = fred_match.GetMetahandle();
     orig_id = fred_match.GetId();
     WriteTestDataToEntry(&trans, &fred_match);
   }
   // Commit it.
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1u, mock_server_->committed_ids().size());
   mock_server_->set_conflict_all_commits(true);
   syncable::Id fred_match_id;
   {
     // Now receive a change from outside.
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry fred_match(&trans, GET_BY_HANDLE, metahandle_fred);
     ASSERT_TRUE(fred_match.good());
     EXPECT_TRUE(fred_match.GetId().ServerKnows());
     fred_match_id = fred_match.GetId();
     mock_server_->AddUpdateBookmark(fred_match_id, trans.root_id(),
         "fred_match", 40, 40, local_cache_guid(), orig_id.GetServerId());
   }
   // Run the syncer.
   for (int i = 0 ; i < 30 ; ++i) {
-    EXPECT_TRUE(SyncShareNudge());
+    SyncShareNudge();
   }
 }
 
 /**
  * In the event that we have a double changed entry, that is changed on both
  * the client and the server, the conflict resolver should just drop one of
  * them and accept the other.
  */
 
 TEST_F(SyncerTest, DoublyChangedWithResolver) {
   syncable::Id local_id;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, root_id_, "Folder");
     ASSERT_TRUE(parent.good());
     parent.PutIsDir(true);
     parent.PutId(parent_id_);
     parent.PutBaseVersion(5);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent_id_, "Pete.htm");
     ASSERT_TRUE(child.good());
     local_id = child.GetId();
     child.PutId(child_id_);
     child.PutBaseVersion(10);
     WriteTestDataToEntry(&wtrans, &child);
   }
   mock_server_->AddUpdateBookmark(child_id_, parent_id_, "Pete2.htm", 11, 10,
                                   local_cache_guid(), local_id.GetServerId());
   mock_server_->set_conflict_all_commits(true);
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
   syncable::Directory::Metahandles children;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     directory()->GetChildHandlesById(&trans, parent_id_, &children);
     // We expect the conflict resolver to preserve the local entry.
     Entry child(&trans, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(child.good());
     EXPECT_TRUE(child.GetIsUnsynced());
     EXPECT_FALSE(child.GetIsUnappliedUpdate());
     EXPECT_TRUE(child.GetSpecifics().has_bookmark());
@@ skipping 17 matching lines @@
     MutableEntry entry(&wtrans, CREATE, BOOKMARKS, root_id_, "Pete");
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetId().ServerKnows());
     local_id = entry.GetId();
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsUnsynced(true);
     entry.PutMtime(test_time);
     entry_metahandle = entry.GetMetahandle();
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   syncable::Id id;
   int64 version;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, syncable::GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     id = entry.GetId();
     EXPECT_TRUE(id.ServerKnows());
     version = entry.GetBaseVersion();
   }
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   update->set_originator_client_item_id(local_id.GetServerId());
   EXPECT_EQ("Pete", update->name());
   EXPECT_EQ(id.GetServerId(), update->id_string());
   EXPECT_EQ(root_id_.GetServerId(), update->parent_id_string());
   EXPECT_EQ(version, update->version());
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, syncable::GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.GetMtime()== test_time);
   }
 }
 
 TEST_F(SyncerTest, ParentAndChildBothMatch) {
   // Disable PREFERENCES which is enabled at the setup step to avoid
@@ skipping 27 matching lines @@
     child.PutSpecifics(DefaultBookmarkSpecifics());
     WriteTestDataToEntry(&wtrans, &child);
   }
   mock_server_->AddUpdateDirectory(parent_id, root_id_, "Folder", 10, 10,
                                    local_cache_guid(),
                                    parent_local_id.GetServerId());
   mock_server_->AddUpdateBookmark(child_id, parent_id, "test.htm", 10, 10,
                                   local_cache_guid(),
                                   child_local_id.GetServerId());
   mock_server_->set_conflict_all_commits(true);
-  EXPECT_TRUE(SyncShareNudge());
-  EXPECT_TRUE(SyncShareNudge());
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
+  SyncShareNudge();
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Directory::Metahandles children;
     directory()->GetChildHandlesById(&trans, root_id_, &children);
     EXPECT_EQ(1u, children.size());
     directory()->GetChildHandlesById(&trans, parent_id, &children);
     EXPECT_EQ(1u, children.size());
     std::vector<int64> unapplied;
     directory()->GetUnappliedUpdateMetaHandles(&trans, all_types, &unapplied);
     EXPECT_EQ(0u, unapplied.size());
     syncable::Directory::Metahandles unsynced;
     directory()->GetUnsyncedMetaHandles(&trans, &unsynced);
     EXPECT_EQ(0u, unsynced.size());
     saw_syncer_event_ = false;
   }
 }
 
 TEST_F(SyncerTest, CommittingNewDeleted) {
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "bob");
     entry.PutIsUnsynced(true);
     entry.PutIsDel(true);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0u, mock_server_->committed_ids().size());
 }
 
 // Original problem synopsis:
 // Check failed: entry->GetBaseVersion()<= entry->GetServerVersion()
 // Client creates entry, client finishes committing entry. Between
 // commit and getting update back, we delete the entry.
 // We get the update for the entry, but the local one was modified
 // so we store the entry but don't apply it. IS_UNAPPLIED_UPDATE is set.
 // We commit deletion and get a new version number.
 // We apply unapplied updates again before we get the update about the deletion.
 // This means we have an unapplied update where server_version < base_version.
 TEST_F(SyncerTest, UnappliedUpdateDuringCommit) {
   // This test is a little fake.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "bob");
     entry.PutId(ids_.FromNumber(20));
     entry.PutBaseVersion(1);
     entry.PutServerVersion(1);
     entry.PutServerParentId(ids_.FromNumber(9999));  // Bad parent.
     entry.PutIsUnsynced(true);
     entry.PutIsUnappliedUpdate(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutServerSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsDel(false);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, session_->status_controller().TotalNumConflictingItems());
   saw_syncer_event_ = false;
 }
 
 // Original problem synopsis:
 //   Illegal parent
 // Unexpected error during sync if we:
 //   make a new folder bob
 //   wait for sync
 //   make a new folder fred
 //   move bob into fred
 //   remove bob
 //   remove fred
 // if no syncing occured midway, bob will have an illegal parent
 TEST_F(SyncerTest, DeletingEntryInFolder) {
   // This test is a little fake.
   int64 existing_metahandle;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "existing");
     ASSERT_TRUE(entry.good());
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsUnsynced(true);
     existing_metahandle = entry.GetMetahandle();
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry newfolder(&trans, CREATE, BOOKMARKS, trans.root_id(), "new");
     ASSERT_TRUE(newfolder.good());
     newfolder.PutIsDir(true);
     newfolder.PutSpecifics(DefaultBookmarkSpecifics());
     newfolder.PutIsUnsynced(true);
 
     MutableEntry existing(&trans, GET_BY_HANDLE, existing_metahandle);
     ASSERT_TRUE(existing.good());
     existing.PutParentId(newfolder.GetId());
     existing.PutIsUnsynced(true);
     EXPECT_TRUE(existing.GetId().ServerKnows());
 
     newfolder.PutIsDel(true);
     existing.PutIsDel(true);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, GetCommitCounters(BOOKMARKS).num_commits_conflict);
 }
 
 TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
   int64 newfolder_metahandle;
 
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10,
                                    foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry newfolder(
         &trans, CREATE, BOOKMARKS, ids_.FromNumber(1), "local");
     ASSERT_TRUE(newfolder.good());
     newfolder.PutIsUnsynced(true);
     newfolder.PutIsDir(true);
     newfolder.PutSpecifics(DefaultBookmarkSpecifics());
     newfolder_metahandle = newfolder.GetMetahandle();
   }
   mock_server_->AddUpdateDirectory(1, 0, "bob", 2, 20,
                                    foreign_cache_guid(), "-1");
   mock_server_->SetLastUpdateDeleted();
   SyncShareConfigure();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, syncable::GET_BY_HANDLE, newfolder_metahandle);
     ASSERT_TRUE(entry.good());
   }
 }
 
 TEST_F(SyncerTest, FolderSwapUpdate) {
   mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10,
                                    foreign_cache_guid(), "-7801");
   mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10,
                                    foreign_cache_guid(), "-1024");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20,
                                    foreign_cache_guid(), "-1024");
   mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20,
                                    foreign_cache_guid(), "-7801");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_TRUE("fred" == id1.GetNonUniqueName());
     EXPECT_TRUE(root_id_ == id1.GetParentId());
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_TRUE("bob" == id2.GetNonUniqueName());
     EXPECT_TRUE(root_id_ == id2.GetParentId());
   }
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, NameCollidingFolderSwapWorksFine) {
   mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10,
                                    foreign_cache_guid(), "-7801");
   mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10,
                                    foreign_cache_guid(), "-1024");
   mock_server_->AddUpdateDirectory(4096, 0, "alice", 1, 10,
                                    foreign_cache_guid(), "-4096");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_TRUE("bob" == id1.GetNonUniqueName());
     EXPECT_TRUE(root_id_ == id1.GetParentId());
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_TRUE("fred" == id2.GetNonUniqueName());
     EXPECT_TRUE(root_id_ == id2.GetParentId());
     Entry id3(&trans, GET_BY_ID, ids_.FromNumber(4096));
     ASSERT_TRUE(id3.good());
     EXPECT_TRUE("alice" == id3.GetNonUniqueName());
     EXPECT_TRUE(root_id_ == id3.GetParentId());
   }
   mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20,
                                    foreign_cache_guid(), "-1024");
   mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20,
                                    foreign_cache_guid(), "-7801");
   mock_server_->AddUpdateDirectory(4096, 0, "bob", 2, 20,
                                    foreign_cache_guid(), "-4096");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_TRUE("fred" == id1.GetNonUniqueName());
     EXPECT_TRUE(root_id_ == id1.GetParentId());
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_TRUE("bob" == id2.GetNonUniqueName());
     EXPECT_TRUE(root_id_ == id2.GetParentId());
@@ skipping 17 matching lines @@
       string nameutf8 = base::StringPrintf("%d", i);
       string name(nameutf8.begin(), nameutf8.end());
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), name);
       e.PutIsUnsynced(true);
       e.PutIsDir(true);
       e.PutSpecifics(DefaultBookmarkSpecifics());
     }
   }
   ASSERT_EQ(items_to_commit, directory()->unsynced_entity_count());
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(num_batches, mock_server_->commit_messages().size());
   EXPECT_EQ(0, directory()->unsynced_entity_count());
 }
 
 // Test that a single failure to contact the server will cause us to exit the
 // commit loop immediately.
 TEST_F(SyncerTest, CommitManyItemsInOneGo_PostBufferFail) {
   uint32 num_batches = 3;
   uint32 items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     for (uint32 i = 0; i < items_to_commit; i++) {
       string nameutf8 = base::StringPrintf("%d", i);
       string name(nameutf8.begin(), nameutf8.end());
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), name);
       e.PutIsUnsynced(true);
       e.PutIsDir(true);
       e.PutSpecifics(DefaultBookmarkSpecifics());
     }
   }
   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);
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(1U, mock_server_->commit_messages().size());
   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;
   uint32 items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     for (uint32 i = 0; i < items_to_commit; i++) {
       string nameutf8 = base::StringPrintf("%d", i);
       string name(nameutf8.begin(), nameutf8.end());
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), name);
       e.PutIsUnsynced(true);
       e.PutIsDir(true);
       e.PutSpecifics(DefaultBookmarkSpecifics());
     }
   }
   ASSERT_EQ(items_to_commit, directory()->unsynced_entity_count());
 
   // Return a CONFLICT response for the first item.
   mock_server_->set_conflict_n_commits(1);
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
 
   // We should stop looping at the first sign of trouble.
   EXPECT_EQ(1U, mock_server_->commit_messages().size());
   EXPECT_EQ(items_to_commit - (kDefaultMaxCommitBatchSize - 1),
             directory()->unsynced_entity_count());
 }
 
 // Tests that sending debug info events works.
 TEST_F(SyncerTest, SendDebugInfoEventsOnGetUpdates_HappyCase) {
   debug_info_getter_->AddDebugEvent();
   debug_info_getter_->AddDebugEvent();
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // Verify we received one GetUpdates request with two debug info events.
   EXPECT_EQ(1U, mock_server_->requests().size());
   ASSERT_TRUE(mock_server_->last_request().has_get_updates());
   EXPECT_EQ(2, mock_server_->last_request().debug_info().events_size());
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // See that we received another GetUpdates request, but that it contains no
   // debug info events.
   EXPECT_EQ(2U, mock_server_->requests().size());
   ASSERT_TRUE(mock_server_->last_request().has_get_updates());
   EXPECT_EQ(0, mock_server_->last_request().debug_info().events_size());
 
   debug_info_getter_->AddDebugEvent();
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // See that we received another GetUpdates request and it contains one debug
   // info event.
   EXPECT_EQ(3U, mock_server_->requests().size());
   ASSERT_TRUE(mock_server_->last_request().has_get_updates());
   EXPECT_EQ(1, mock_server_->last_request().debug_info().events_size());
 }
 
 // Tests that debug info events are dropped on server error.
 TEST_F(SyncerTest, SendDebugInfoEventsOnGetUpdates_PostFailsDontDrop) {
   debug_info_getter_->AddDebugEvent();
   debug_info_getter_->AddDebugEvent();
 
   mock_server_->FailNextPostBufferToPathCall();
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
 
   // Verify we attempted to send one GetUpdates request with two debug info
   // events.
   EXPECT_EQ(1U, mock_server_->requests().size());
   ASSERT_TRUE(mock_server_->last_request().has_get_updates());
   EXPECT_EQ(2, mock_server_->last_request().debug_info().events_size());
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // See that the client resent the two debug info events.
   EXPECT_EQ(2U, mock_server_->requests().size());
   ASSERT_TRUE(mock_server_->last_request().has_get_updates());
   EXPECT_EQ(2, mock_server_->last_request().debug_info().events_size());
 
   // The previous send was successful so this next one shouldn't generate any
   // debug info events.
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(3U, mock_server_->requests().size());
   ASSERT_TRUE(mock_server_->last_request().has_get_updates());
   EXPECT_EQ(0, mock_server_->last_request().debug_info().events_size());
 }
 
 // Tests that commit failure with conflict will trigger GetUpdates for next
-// cycle of sync
+// sycle of sync
 TEST_F(SyncerTest, CommitFailureWithConflict) {
   ConfigureNoGetUpdatesRequired();
   CreateUnsyncedDirectory("X", "id_X");
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 
   CreateUnsyncedDirectory("Y", "id_Y");
   mock_server_->set_conflict_n_commits(1);
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired());
 
   nudge_tracker_.RecordSuccessfulSyncCycle();
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 }
 
 // Tests that sending debug info events on Commit works.
 TEST_F(SyncerTest, SendDebugInfoEventsOnCommit_HappyCase) {
   // Make sure GetUpdate isn't call as it would "steal" debug info events before
   // Commit has a chance to send them.
   ConfigureNoGetUpdatesRequired();
 
   // Generate a debug info event and trigger a commit.
   debug_info_getter_->AddDebugEvent();
   CreateUnsyncedDirectory("X", "id_X");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // Verify that the last request received is a Commit and that it contains a
   // debug info event.
   EXPECT_EQ(1U, mock_server_->requests().size());
   ASSERT_TRUE(mock_server_->last_request().has_commit());
   EXPECT_EQ(1, mock_server_->last_request().debug_info().events_size());
 
   // Generate another commit, but no debug info event.
   CreateUnsyncedDirectory("Y", "id_Y");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // See that it was received and contains no debug info events.
   EXPECT_EQ(2U, mock_server_->requests().size());
   ASSERT_TRUE(mock_server_->last_request().has_commit());
   EXPECT_EQ(0, mock_server_->last_request().debug_info().events_size());
 }
 
 // Tests that debug info events are not dropped on server error.
 TEST_F(SyncerTest, SendDebugInfoEventsOnCommit_PostFailsDontDrop) {
   // Make sure GetUpdate isn't call as it would "steal" debug info events before
   // Commit has a chance to send them.
   ConfigureNoGetUpdatesRequired();
 
   mock_server_->FailNextPostBufferToPathCall();
 
   // Generate a debug info event and trigger a commit.
   debug_info_getter_->AddDebugEvent();
   CreateUnsyncedDirectory("X", "id_X");
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
 
   // Verify that the last request sent is a Commit and that it contains a debug
   // info event.
   EXPECT_EQ(1U, mock_server_->requests().size());
   ASSERT_TRUE(mock_server_->last_request().has_commit());
   EXPECT_EQ(1, mock_server_->last_request().debug_info().events_size());
 
   // Try again.
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // Verify that we've received another Commit and that it contains a debug info
   // event (just like the previous one).
   EXPECT_EQ(2U, mock_server_->requests().size());
   ASSERT_TRUE(mock_server_->last_request().has_commit());
   EXPECT_EQ(1, mock_server_->last_request().debug_info().events_size());
 
   // Generate another commit and try again.
   CreateUnsyncedDirectory("Y", "id_Y");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // See that it was received and contains no debug info events.
   EXPECT_EQ(3U, mock_server_->requests().size());
   ASSERT_TRUE(mock_server_->last_request().has_commit());
   EXPECT_EQ(0, mock_server_->last_request().debug_info().events_size());
 }
 
 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;
 
   // Create a lot of updates for which the parent does not exist yet.
   // Generate a huge deep tree which should all fail to apply at first.
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     for (int i = 0; i < item_count ; i++) {
       syncable::Id next_id = ids_.NewServerId();
       syncable::Id local_id = ids_.NewLocalId();
       tree_ids.push_back(next_id);
       mock_server_->AddUpdateDirectory(next_id, last_id, "BOB", 2, 20,
                                        foreign_cache_guid(),
                                        local_id.GetServerId());
       last_id = next_id;
     }
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // Check they're in the expected conflict state.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     for (int i = 0; i < item_count; i++) {
       Entry e(&trans, GET_BY_ID, tree_ids[i]);
       // They should all exist but none should be applied.
       ASSERT_TRUE(e.good());
       EXPECT_TRUE(e.GetIsDel());
       EXPECT_TRUE(e.GetIsUnappliedUpdate());
     }
   }
 
   // Add the missing parent directory.
   mock_server_->AddUpdateDirectory(parent_id, TestIdFactory::root(),
       "BOB", 2, 20, foreign_cache_guid(), "-3500");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // Now they should all be OK.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     for (int i = 0; i < item_count; i++) {
       Entry e(&trans, GET_BY_ID, tree_ids[i]);
       ASSERT_TRUE(e.good());
       EXPECT_FALSE(e.GetIsDel());
       EXPECT_FALSE(e.GetIsUnappliedUpdate());
     }
   }
 }
 
 TEST_F(SyncerTest, DontCrashOnCaseChange) {
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10,
                                    foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry e(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(e.good());
     e.PutIsUnsynced(true);
   }
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(1, 0, "BOB", 2, 20,
                                    foreign_cache_guid(), "-1");
-  EXPECT_FALSE(SyncShareNudge());  // USED TO CAUSE AN ASSERT
+  SyncShareNudge();  // USED TO CAUSE AN ASSERT
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, UnsyncedItemAndUpdate) {
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10,
                                    foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(2, 0, "bob", 2, 20,
                                    foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());  // USED TO CAUSE AN ASSERT
+  SyncShareNudge();  // USED TO CAUSE AN ASSERT
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath) {
   mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10,
                                   foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   int64 local_folder_handle;
   syncable::Id local_folder_id;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry new_entry(
         &wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Bar.htm");
     ASSERT_TRUE(new_entry.good());
     local_folder_id = new_entry.GetId();
     local_folder_handle = new_entry.GetMetahandle();
     new_entry.PutIsUnsynced(true);
     new_entry.PutSpecifics(DefaultBookmarkSpecifics());
     MutableEntry old(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(old.good());
     WriteTestDataToEntry(&wtrans, &old);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 20, 20,
                                   foreign_cache_guid(), "-1");
   mock_server_->set_conflict_all_commits(true);
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
   saw_syncer_event_ = false;
   {
     // Update #20 should have been dropped in favor of the local version.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_TRUE(local.GetMetahandle()!= server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_TRUE(server.GetIsUnsynced());
     EXPECT_TRUE(local.GetIsUnsynced());
     EXPECT_EQ("Foo.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
   }
   // Allow local changes to commit.
   mock_server_->set_conflict_all_commits(false);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   saw_syncer_event_ = false;
 
   // Now add a server change to make the two names equal.  There should
   // be no conflict with that, since names are not unique.
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 30, 30,
                                   foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   saw_syncer_event_ = false;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_TRUE(local.GetMetahandle()!= server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_FALSE(server.GetIsUnsynced());
     EXPECT_FALSE(local.GetIsUnsynced());
     EXPECT_EQ("Bar.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
     EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
         server.GetSpecifics().bookmark().url());
   }
 }
 
 // Same as NewEntryAnddServerEntrySharePath, but using the old-style protocol.
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath_OldBookmarksProto) {
   mock_server_->set_use_legacy_bookmarks_protocol(true);
   mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10,
                                   foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   int64 local_folder_handle;
   syncable::Id local_folder_id;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry new_entry(
         &wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Bar.htm");
     ASSERT_TRUE(new_entry.good());
     local_folder_id = new_entry.GetId();
     local_folder_handle = new_entry.GetMetahandle();
     new_entry.PutIsUnsynced(true);
     new_entry.PutSpecifics(DefaultBookmarkSpecifics());
     MutableEntry old(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(old.good());
     WriteTestDataToEntry(&wtrans, &old);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 20, 20,
                                   foreign_cache_guid(), "-1");
   mock_server_->set_conflict_all_commits(true);
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
   saw_syncer_event_ = false;
   {
     // Update #20 should have been dropped in favor of the local version.
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_TRUE(local.GetMetahandle()!= server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_TRUE(server.GetIsUnsynced());
     EXPECT_TRUE(local.GetIsUnsynced());
     EXPECT_EQ("Foo.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
   }
   // Allow local changes to commit.
   mock_server_->set_conflict_all_commits(false);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   saw_syncer_event_ = false;
 
   // Now add a server change to make the two names equal.  There should
   // be no conflict with that, since names are not unique.
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 30, 30,
                                   foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   saw_syncer_event_ = false;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_TRUE(local.GetMetahandle()!= server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_FALSE(server.GetIsUnsynced());
     EXPECT_FALSE(local.GetIsUnsynced());
     EXPECT_EQ("Bar.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
     EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
         server.GetSpecifics().bookmark().url());
   }
 }
 
 // Circular links should be resolved by the server.
 TEST_F(SyncerTest, SiblingDirectoriesBecomeCircular) {
   // we don't currently resolve this. This test ensures we don't.
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10,
                                    foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutParentId(ids_.FromNumber(2));
     A.PutNonUniqueName("B");
   }
   mock_server_->AddUpdateDirectory(2, 1, "A", 20, 20,
                                    foreign_cache_guid(), "-2");
   mock_server_->set_conflict_all_commits(true);
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
   saw_syncer_event_ = false;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_TRUE(A.GetNonUniqueName()== "B");
     EXPECT_TRUE(B.GetNonUniqueName()== "B");
   }
 }
 
 TEST_F(SyncerTest, SwapEntryNames) {
   // Simple transaction test.
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10,
                                    foreign_cache_guid(), "-2");
   mock_server_->set_conflict_all_commits(true);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.PutIsUnsynced(true);
     A.PutNonUniqueName("C");
     B.PutNonUniqueName("A");
     A.PutNonUniqueName("B");
   }
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, DualDeletionWithNewItemNameClash) {
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateBookmark(2, 0, "B", 10, 10,
                                   foreign_cache_guid(), "-2");
   mock_server_->set_conflict_all_commits(true);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     WriteTestDataToEntry(&trans, &B);
     B.PutIsDel(true);
   }
   mock_server_->AddUpdateBookmark(2, 0, "A", 11, 11,
                                   foreign_cache_guid(), "-2");
   mock_server_->SetLastUpdateDeleted();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_FALSE(B.GetIsUnsynced());
     EXPECT_FALSE(B.GetIsUnappliedUpdate());
   }
   saw_syncer_event_ = false;
 }
 
 // When we undelete an entity as a result of conflict resolution, we reuse the
 // existing server id and preserve the old version, simply updating the server
 // version with the new non-deleted entity.
 TEST_F(SyncerTest, ResolveWeWroteTheyDeleted) {
   int64 bob_metahandle;
 
   mock_server_->AddUpdateBookmark(1, 0, "bob", 1, 10,
                                   foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob_metahandle = bob.GetMetahandle();
     WriteTestDataToEntry(&trans, &bob);
   }
   mock_server_->AddUpdateBookmark(1, 0, "bob", 2, 10,
                                   foreign_cache_guid(), "-1");
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
-  EXPECT_FALSE(SyncShareNudge());
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry bob(&trans, GET_BY_HANDLE, bob_metahandle);
     ASSERT_TRUE(bob.good());
     EXPECT_TRUE(bob.GetIsUnsynced());
     EXPECT_TRUE(bob.GetId().ServerKnows());
     EXPECT_FALSE(bob.GetIsUnappliedUpdate());
     EXPECT_FALSE(bob.GetIsDel());
     EXPECT_EQ(2, bob.GetServerVersion());
     EXPECT_EQ(2, bob.GetBaseVersion());
@@ skipping 15 matching lines @@
     ASSERT_TRUE(folder2.good());
     folder2.PutIsUnsynced(false);
     folder2.PutIsDir(true);
     folder2.PutSpecifics(DefaultBookmarkSpecifics());
     folder2.PutBaseVersion(3);
     folder2.PutId(syncable::Id::CreateFromServerId("mock_server:10000"));
   }
   mock_server_->set_next_new_id(10000);
   EXPECT_EQ(1u, directory()->unsynced_entity_count());
   // we get back a bad id in here (should never happen).
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1u, directory()->unsynced_entity_count());
-  EXPECT_TRUE(SyncShareNudge());  // another bad id in here.
+  SyncShareNudge();  // another bad id in here.
   EXPECT_EQ(0u, directory()->unsynced_entity_count());
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, DeletedEntryWithBadParentInLoopCalculation) {
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10,
                                    foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     // This is valid, because the parent could have gone away a long time ago.
     bob.PutParentId(ids_.FromNumber(54));
     bob.PutIsDel(true);
     bob.PutIsUnsynced(true);
   }
   mock_server_->AddUpdateDirectory(2, 1, "fred", 1, 10,
                                    foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
+  SyncShareNudge();
 }
 
 TEST_F(SyncerTest, ConflictResolverMergesLocalDeleteAndServerUpdate) {
   syncable::Id local_id;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 
     MutableEntry local_deleted(
         &trans, CREATE, BOOKMARKS, trans.root_id(), "name");
     local_id = local_deleted.GetId();
     local_deleted.PutId(ids_.FromNumber(1));
     local_deleted.PutBaseVersion(1);
     local_deleted.PutIsDel(true);
     local_deleted.PutIsDir(false);
     local_deleted.PutIsUnsynced(true);
     local_deleted.PutSpecifics(DefaultBookmarkSpecifics());
   }
 
   mock_server_->AddUpdateBookmark(ids_.FromNumber(1), root_id_, "name", 10, 10,
                                   local_cache_guid(),
                                   local_id.GetServerId());
 
   // We don't care about actually committing, just the resolution.
   mock_server_->set_conflict_all_commits(true);
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry local_deleted(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_TRUE(local_deleted.GetBaseVersion()== 10);
     EXPECT_TRUE(local_deleted.GetIsUnappliedUpdate()== false);
     EXPECT_TRUE(local_deleted.GetIsUnsynced()== true);
     EXPECT_TRUE(local_deleted.GetIsDel()== true);
     EXPECT_TRUE(local_deleted.GetIsDir()== false);
   }
@@ skipping 18 matching lines @@
 
   // Server update: entry-type object (not a container), revision 10.
   mock_server_->AddUpdateBookmark(ids_.FromNumber(1), root_id_, "name", 10, 10,
                                   local_cache_guid(),
                                   ids_.FromNumber(1).GetServerId());
 
   // Don't attempt to commit.
   mock_server_->set_conflict_all_commits(true);
 
   // The syncer should not attempt to apply the invalid update.
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry local_deleted(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_TRUE(local_deleted.GetBaseVersion()== 1);
     EXPECT_TRUE(local_deleted.GetIsUnappliedUpdate()== false);
     EXPECT_TRUE(local_deleted.GetIsUnsynced()== true);
     EXPECT_TRUE(local_deleted.GetIsDel()== true);
     EXPECT_TRUE(local_deleted.GetIsDir()== true);
   }
 }
 
 // Bug Synopsis:
 // Merge conflict resolution will merge a new local entry with another entry
 // that needs updates, resulting in CHECK.
 TEST_F(SyncerTest, MergingExistingItems) {
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10,
                                   local_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(
         &trans, CREATE, BOOKMARKS, trans.root_id(), "Copy of base");
     WriteTestDataToEntry(&trans, &entry);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50,
                                   local_cache_guid(), "-1");
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
 }
 
 // In this test a long changelog contains a child at the start of the changelog
 // and a parent at the end. While these updates are in progress the client would
 // appear stuck.
 TEST_F(SyncerTest, LongChangelistWithApplicationConflict) {
   const int depth = 400;
   syncable::Id folder_id = ids_.FromNumber(1);
 
   // First we an item in a folder in the root. However the folder won't come
   // till much later.
   syncable::Id stuck_entry_id = TestIdFactory::FromNumber(99999);
   mock_server_->AddUpdateDirectory(stuck_entry_id,
       folder_id, "stuck", 1, 1,
       foreign_cache_guid(), "-99999");
   mock_server_->SetChangesRemaining(depth - 1);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // Buffer up a very long series of downloads.
   // We should never be stuck (conflict resolution shouldn't
   // kick in so long as we're making forward progress).
   for (int i = 0; i < depth; i++) {
     mock_server_->NextUpdateBatch();
     mock_server_->SetNewTimestamp(i + 1);
     mock_server_->SetChangesRemaining(depth - i);
   }
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // Ensure our folder hasn't somehow applied.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry child(&trans, GET_BY_ID, stuck_entry_id);
     EXPECT_TRUE(child.good());
     EXPECT_TRUE(child.GetIsUnappliedUpdate());
     EXPECT_TRUE(child.GetIsDel());
     EXPECT_FALSE(child.GetIsUnsynced());
   }
 
   // And finally the folder.
   mock_server_->AddUpdateDirectory(folder_id,
       TestIdFactory::root(), "folder", 1, 1,
       foreign_cache_guid(), "-1");
   mock_server_->SetChangesRemaining(0);
-  EXPECT_TRUE(SyncShareNudge());
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
+  SyncShareNudge();
   // Check that everything is as expected after the commit.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, folder_id);
     ASSERT_TRUE(entry.good());
     Entry child(&trans, GET_BY_ID, stuck_entry_id);
     EXPECT_EQ(entry.GetId(), child.GetParentId());
     EXPECT_EQ("stuck", child.GetNonUniqueName());
     EXPECT_TRUE(child.good());
   }
 }
 
 TEST_F(SyncerTest, DontMergeTwoExistingItems) {
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10,
                                   foreign_cache_guid(), "-1");
   mock_server_->AddUpdateBookmark(2, 0, "base2", 10, 10,
                                   foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     entry.PutNonUniqueName("Copy of base");
     entry.PutIsUnsynced(true);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50,
                                   foreign_cache_guid(), "-1");
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry1(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_FALSE(entry1.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry1.GetIsUnsynced());
     EXPECT_FALSE(entry1.GetIsDel());
     Entry entry2(&trans, GET_BY_ID, ids_.FromNumber(2));
     EXPECT_FALSE(entry2.GetIsUnappliedUpdate());
     EXPECT_TRUE(entry2.GetIsUnsynced());
     EXPECT_FALSE(entry2.GetIsDel());
     EXPECT_EQ(entry1.GetNonUniqueName(), entry2.GetNonUniqueName());
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteUpdate) {
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateDirectory(2, 1, "bar", 1, 2,
                                    foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   mock_server_->AddUpdateDirectory(2, 1, "bar", 2, 3,
                                    foreign_cache_guid(), "-2");
   mock_server_->SetLastUpdateDeleted();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   int64 metahandle;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.GetIsDel());
     metahandle = entry.GetMetahandle();
   }
   mock_server_->AddUpdateDirectory(1, 0, "foo", 2, 4,
                                    foreign_cache_guid(), "-1");
   mock_server_->SetLastUpdateDeleted();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // This used to be rejected as it's an undeletion. Now, it results in moving
   // the delete path aside.
   mock_server_->AddUpdateDirectory(2, 1, "bar", 3, 5,
                                    foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
     EXPECT_TRUE(entry.GetIsUnappliedUpdate());
     EXPECT_NE(entry.GetMetahandle(), metahandle);
   }
 }
 
 TEST_F(SyncerTest, TestMoveSanitizedNamedFolder) {
   mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateDirectory(2, 0, ":::", 1, 2,
                                    foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     entry.PutParentId(ids_.FromNumber(1));
     EXPECT_TRUE(entry.PutIsUnsynced(true));
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // We use the same sync ts as before so our times match up.
   mock_server_->AddUpdateDirectory(2, 1, ":::", 2, 2,
                                    foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 }
 
 // Don't crash when this occurs.
 TEST_F(SyncerTest, UpdateWhereParentIsNotAFolder) {
   mock_server_->AddUpdateBookmark(1, 0, "B", 10, 10,
                                   foreign_cache_guid(), "-1");
   mock_server_->AddUpdateDirectory(2, 1, "BookmarkParent", 10, 10,
                                    foreign_cache_guid(), "-2");
   // Used to cause a CHECK
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     Entry good_entry(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(good_entry.good());
     EXPECT_FALSE(good_entry.GetIsUnappliedUpdate());
     Entry bad_parent(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(bad_parent.good());
     EXPECT_TRUE(bad_parent.GetIsUnappliedUpdate());
   }
 }
 
 TEST_F(SyncerTest, DirectoryUpdateTest) {
   Id in_root_id = ids_.NewServerId();
   Id in_in_root_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(in_root_id, TestIdFactory::root(),
                                    "in_root_name", 2, 2,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateDirectory(in_in_root_id, in_root_id,
                                    "in_in_root_name", 3, 3,
                                    foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry in_root(&trans, GET_BY_ID, in_root_id);
     ASSERT_TRUE(in_root.good());
     EXPECT_EQ("in_root_name", in_root.GetNonUniqueName());
     EXPECT_EQ(TestIdFactory::root(), in_root.GetParentId());
 
     Entry in_in_root(&trans, GET_BY_ID, in_in_root_id);
     ASSERT_TRUE(in_in_root.good());
     EXPECT_EQ("in_in_root_name", in_in_root.GetNonUniqueName());
@@ skipping 17 matching lines @@
     foo_metahandle = parent.GetMetahandle();
 
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent.GetId(), "bar");
     ASSERT_TRUE(child.good());
     child.PutIsUnsynced(true);
     child.PutIsDir(true);
     child.PutSpecifics(DefaultBookmarkSpecifics());
     bar_metahandle = child.GetMetahandle();
     in_dir_id = parent.GetId();
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry fail_by_old_id_entry(&trans, GET_BY_ID, in_root_id);
     ASSERT_FALSE(fail_by_old_id_entry.good());
 
     Entry foo_entry(&trans, GET_BY_HANDLE, foo_metahandle);
     ASSERT_TRUE(foo_entry.good());
     EXPECT_EQ("foo", foo_entry.GetNonUniqueName());
     EXPECT_NE(foo_entry.GetId(), in_root_id);
 
@@ skipping 14 matching lines @@
   command->set_sessions_commit_delay_seconds(3141);
   sync_pb::CustomNudgeDelay* bookmark_delay =
       command->add_custom_nudge_delays();
   bookmark_delay->set_datatype_id(
       GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   bookmark_delay->set_delay_ms(950);
   command->set_client_invalidation_hint_buffer_size(11);
   mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1,
                                    foreign_cache_guid(), "-1");
   mock_server_->SetGUClientCommand(command);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(TimeDelta::FromSeconds(8), last_short_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(800), last_long_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(3141), last_sessions_commit_delay_);
   EXPECT_EQ(TimeDelta::FromMilliseconds(950), last_bookmarks_commit_delay_);
   EXPECT_EQ(11, last_client_invalidation_hint_buffer_size_);
 
   command = new ClientCommand();
   command->set_set_sync_poll_interval(180);
   command->set_set_sync_long_poll_interval(190);
   command->set_sessions_commit_delay_seconds(2718);
   bookmark_delay = command->add_custom_nudge_delays();
   bookmark_delay->set_datatype_id(
       GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   bookmark_delay->set_delay_ms(1050);
   command->set_client_invalidation_hint_buffer_size(9);
   mock_server_->AddUpdateDirectory(
       1, 0, "in_root", 1, 1, foreign_cache_guid(), "-1");
   mock_server_->SetGUClientCommand(command);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(TimeDelta::FromSeconds(180), last_short_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(190), last_long_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(2718), last_sessions_commit_delay_);
   EXPECT_EQ(TimeDelta::FromMilliseconds(1050), last_bookmarks_commit_delay_);
   EXPECT_EQ(9, last_client_invalidation_hint_buffer_size_);
 }
 
 TEST_F(SyncerTest, TestClientCommandDuringCommit) {
   using sync_pb::ClientCommand;
 
   ClientCommand* command = new ClientCommand();
   command->set_set_sync_poll_interval(8);
   command->set_set_sync_long_poll_interval(800);
   command->set_sessions_commit_delay_seconds(3141);
   sync_pb::CustomNudgeDelay* bookmark_delay =
       command->add_custom_nudge_delays();
   bookmark_delay->set_datatype_id(
       GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   bookmark_delay->set_delay_ms(950);
   command->set_client_invalidation_hint_buffer_size(11);
   CreateUnsyncedDirectory("X", "id_X");
   mock_server_->SetCommitClientCommand(command);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(TimeDelta::FromSeconds(8), last_short_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(800), last_long_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(3141), last_sessions_commit_delay_);
   EXPECT_EQ(TimeDelta::FromMilliseconds(950), last_bookmarks_commit_delay_);
   EXPECT_EQ(11, last_client_invalidation_hint_buffer_size_);
 
   command = new ClientCommand();
   command->set_set_sync_poll_interval(180);
   command->set_set_sync_long_poll_interval(190);
   command->set_sessions_commit_delay_seconds(2718);
   bookmark_delay = command->add_custom_nudge_delays();
   bookmark_delay->set_datatype_id(
       GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   bookmark_delay->set_delay_ms(1050);
   command->set_client_invalidation_hint_buffer_size(9);
   CreateUnsyncedDirectory("Y", "id_Y");
   mock_server_->SetCommitClientCommand(command);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(TimeDelta::FromSeconds(180), last_short_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(190), last_long_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(2718), last_sessions_commit_delay_);
   EXPECT_EQ(TimeDelta::FromMilliseconds(1050), last_bookmarks_commit_delay_);
   EXPECT_EQ(9, last_client_invalidation_hint_buffer_size_);
 }
 
 TEST_F(SyncerTest, EnsureWeSendUpOldParent) {
   syncable::Id folder_one_id = ids_.FromNumber(1);
   syncable::Id folder_two_id = ids_.FromNumber(2);
 
   mock_server_->AddUpdateDirectory(folder_one_id, TestIdFactory::root(),
       "folder_one", 1, 1, foreign_cache_guid(), "-1");
   mock_server_->AddUpdateDirectory(folder_two_id, TestIdFactory::root(),
       "folder_two", 1, 1, foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   {
     // A moved entry should send an "old parent."
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_ID, folder_one_id);
     ASSERT_TRUE(entry.good());
     entry.PutParentId(folder_two_id);
     entry.PutIsUnsynced(true);
     // A new entry should send no "old parent."
     MutableEntry create(
         &trans, CREATE, BOOKMARKS, trans.root_id(), "new_folder");
     create.PutIsUnsynced(true);
     create.PutSpecifics(DefaultBookmarkSpecifics());
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   const sync_pb::CommitMessage& commit = mock_server_->last_sent_commit();
   ASSERT_EQ(2, commit.entries_size());
   EXPECT_TRUE(commit.entries(0).parent_id_string() == "2");
   EXPECT_TRUE(commit.entries(0).old_parent_id() == "0");
   EXPECT_FALSE(commit.entries(1).has_old_parent_id());
 }
 
 TEST_F(SyncerTest, Test64BitVersionSupport) {
   int64 really_big_int = std::numeric_limits<int64>::max() - 12;
   const string name("ringo's dang orang ran rings around my o-ring");
@@ skipping 15 matching lines @@
   ASSERT_TRUE(entry.good());
   EXPECT_TRUE(really_big_int == entry.GetBaseVersion());
 }
 
 TEST_F(SyncerTest, TestSimpleUndelete) {
   Id id = ids_.MakeServer("undeletion item"), root = TestIdFactory::root();
   mock_server_->set_conflict_all_commits(true);
   // Let there be an entry from the server.
   mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10,
                                   foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // Check it out and delete it.
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsDel());
     // Delete it locally.
     entry.PutIsDel(true);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // Confirm we see IS_DEL and not SERVER_IS_DEL.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_TRUE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // Update from server confirming deletion.
   mock_server_->AddUpdateBookmark(id, root, "foo", 2, 11,
                                   foreign_cache_guid(), "-1");
   mock_server_->SetLastUpdateDeleted();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // IS_DEL AND SERVER_IS_DEL now both true.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_TRUE(entry.GetIsDel());
     EXPECT_TRUE(entry.GetServerIsDel());
   }
   // Undelete from server.
   mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12,
                                   foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // IS_DEL and SERVER_IS_DEL now both false.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteWithMissingDeleteUpdate) {
   Id id = ids_.MakeServer("undeletion item"), root = TestIdFactory::root();
   // Let there be a entry, from the server.
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10,
                                   foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // Check it out and delete it.
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsDel());
     // Delete it locally.
     entry.PutIsDel(true);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // Confirm we see IS_DEL and not SERVER_IS_DEL.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_TRUE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // Say we do not get an update from server confirming deletion. Undelete
   // from server
   mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12,
                                   foreign_cache_guid(), "-1");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // IS_DEL and SERVER_IS_DEL now both false.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteIgnoreCorrectlyUnappliedUpdate) {
   Id id1 = ids_.MakeServer("first"), id2 = ids_.MakeServer("second");
   Id root = TestIdFactory::root();
   // Duplicate! expect path clashing!
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(id1, root, "foo", 1, 10,
                                   foreign_cache_guid(), "-1");
   mock_server_->AddUpdateBookmark(id2, root, "foo", 1, 10,
                                   foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   mock_server_->AddUpdateBookmark(id2, root, "foo2", 2, 20,
                                   foreign_cache_guid(), "-2");
-  EXPECT_TRUE(SyncShareNudge());  // Now just don't explode.
+  SyncShareNudge();  // Now just don't explode.
 }
 
 TEST_F(SyncerTest, ClientTagServerCreatedUpdatesWork) {
   mock_server_->AddUpdateDirectory(1, 0, "permitem1", 1, 10,
                                    foreign_cache_guid(), "-1");
   mock_server_->SetLastUpdateClientTag("permfolder");
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
     ASSERT_TRUE(perm_folder.good());
     EXPECT_FALSE(perm_folder.GetIsDel());
     EXPECT_FALSE(perm_folder.GetIsUnappliedUpdate());
     EXPECT_FALSE(perm_folder.GetIsUnsynced());
     EXPECT_EQ(perm_folder.GetUniqueClientTag(), "permfolder");
     EXPECT_EQ(perm_folder.GetNonUniqueName(), "permitem1");
   }
 
   mock_server_->AddUpdateDirectory(1, 0, "permitem_renamed", 10, 100,
                                    foreign_cache_guid(), "-1");
   mock_server_->SetLastUpdateClientTag("permfolder");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
     ASSERT_TRUE(perm_folder.good());
     EXPECT_FALSE(perm_folder.GetIsDel());
     EXPECT_FALSE(perm_folder.GetIsUnappliedUpdate());
     EXPECT_FALSE(perm_folder.GetIsUnsynced());
     EXPECT_EQ(perm_folder.GetUniqueClientTag(), "permfolder");
     EXPECT_EQ(perm_folder.GetNonUniqueName(), "permitem_renamed");
   }
 }
 
 TEST_F(SyncerTest, ClientTagIllegalUpdateIgnored) {
   mock_server_->AddUpdateDirectory(1, 0, "permitem1", 1, 10,
                                    foreign_cache_guid(), "-1");
   mock_server_->SetLastUpdateClientTag("permfolder");
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
     ASSERT_TRUE(perm_folder.good());
     EXPECT_FALSE(perm_folder.GetIsUnappliedUpdate());
     EXPECT_FALSE(perm_folder.GetIsUnsynced());
     EXPECT_EQ(perm_folder.GetUniqueClientTag(), "permfolder");
     EXPECT_TRUE(perm_folder.GetNonUniqueName()== "permitem1");
     EXPECT_TRUE(perm_folder.GetId().ServerKnows());
   }
 
   mock_server_->AddUpdateDirectory(1, 0, "permitem_renamed", 10, 100,
                                    foreign_cache_guid(), "-1");
   mock_server_->SetLastUpdateClientTag("wrongtag");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     // This update is rejected because it has the same ID, but a
     // different tag than one that is already on the client.
     // The client has a ServerKnows ID, which cannot be overwritten.
     Entry rejected_update(&trans, GET_BY_CLIENT_TAG, "wrongtag");
     EXPECT_FALSE(rejected_update.good());
 
@@ skipping 19 matching lines @@
     EXPECT_FALSE(pref.GetId().ServerKnows());
     original_metahandle = pref.GetMetahandle();
   }
 
   syncable::Id server_id = TestIdFactory::MakeServer("id");
   mock_server_->AddUpdatePref(server_id.GetServerId(),
                               ids_.root().GetServerId(),
                               "tag", 10, 100);
   mock_server_->set_conflict_all_commits(true);
 
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
   // This should cause client tag reunion, preserving the metahandle.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry pref(&trans, GET_BY_CLIENT_TAG, "tag");
     ASSERT_TRUE(pref.good());
     EXPECT_FALSE(pref.GetIsDel());
     EXPECT_FALSE(pref.GetIsUnappliedUpdate());
     EXPECT_TRUE(pref.GetIsUnsynced());
     EXPECT_EQ(10, pref.GetBaseVersion());
     // Entry should have been given the new ID while preserving the
     // metahandle; client should have won the conflict resolution.
     EXPECT_EQ(original_metahandle, pref.GetMetahandle());
     EXPECT_EQ("tag", pref.GetUniqueClientTag());
     EXPECT_TRUE(pref.GetId().ServerKnows());
   }
 
   mock_server_->set_conflict_all_commits(false);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // The resolved entry ought to commit cleanly.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry pref(&trans, GET_BY_CLIENT_TAG, "tag");
     ASSERT_TRUE(pref.good());
     EXPECT_FALSE(pref.GetIsDel());
     EXPECT_FALSE(pref.GetIsUnappliedUpdate());
     EXPECT_FALSE(pref.GetIsUnsynced());
@@ skipping 22 matching lines @@
     // helps us clean up those entries).
     pref.PutIsDel(true);
   }
 
   // Prepare an update with the same unique client tag.
   syncable::Id server_id = TestIdFactory::MakeServer("id");
   mock_server_->AddUpdatePref(server_id.GetServerId(),
                               ids_.root().GetServerId(),
                               "tag", 10, 100);
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // The local entry will be overwritten.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry pref(&trans, GET_BY_CLIENT_TAG, "tag");
     ASSERT_TRUE(pref.good());
     ASSERT_TRUE(pref.GetId().ServerKnows());
     EXPECT_FALSE(pref.GetIsDel());
     EXPECT_FALSE(pref.GetIsUnappliedUpdate());
     EXPECT_FALSE(pref.GetIsUnsynced());
     EXPECT_EQ(pref.GetBaseVersion(), 10);
     EXPECT_EQ(pref.GetUniqueClientTag(), "tag");
   }
 }
 
 TEST_F(SyncerTest, ClientTagUpdateClashesWithLocalEntry) {
   // This test is written assuming that ID comparison
   // will work out in a particular way.
   EXPECT_TRUE(ids_.FromNumber(1) < ids_.FromNumber(2));
   EXPECT_TRUE(ids_.FromNumber(3) < ids_.FromNumber(4));
 
   syncable::Id id1 = TestIdFactory::MakeServer("1");
   mock_server_->AddUpdatePref(id1.GetServerId(), "", "tag1", 10, 100);
 
   syncable::Id id4 = TestIdFactory::MakeServer("4");
   mock_server_->AddUpdatePref(id4.GetServerId(), "", "tag2", 11, 110);
 
   mock_server_->set_conflict_all_commits(true);
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   int64 tag1_metahandle = syncable::kInvalidMetaHandle;
   int64 tag2_metahandle = syncable::kInvalidMetaHandle;
   // This should cause client tag overwrite.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry tag1(&trans, GET_BY_CLIENT_TAG, "tag1");
     ASSERT_TRUE(tag1.good());
     ASSERT_TRUE(tag1.GetId().ServerKnows());
     ASSERT_TRUE(id1 == tag1.GetId());
@@ skipping 21 matching lines @@
 
     syncable::Directory::Metahandles children;
     directory()->GetChildHandlesById(&trans, pref_root.GetId(), &children);
     ASSERT_EQ(2U, children.size());
   }
 
   syncable::Id id2 = TestIdFactory::MakeServer("2");
   mock_server_->AddUpdatePref(id2.GetServerId(), "", "tag1", 12, 120);
   syncable::Id id3 = TestIdFactory::MakeServer("3");
   mock_server_->AddUpdatePref(id3.GetServerId(), "", "tag2", 13, 130);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry tag1(&trans, GET_BY_CLIENT_TAG, "tag1");
     ASSERT_TRUE(tag1.good());
     ASSERT_TRUE(tag1.GetId().ServerKnows());
     ASSERT_EQ(id1, tag1.GetId())
         << "ID 1 should be kept, since it was less than ID 2.";
     EXPECT_FALSE(tag1.GetIsDel());
@@ skipping 55 matching lines @@
   mock_server_->AddUpdatePref(ids_.FromNumber(202).GetServerId(), "", "tag c",
                               19, 190);
   mock_server_->AddUpdatePref(ids_.FromNumber(204).GetServerId(), "", "tag c",
                               20, 200);
   // Least ID: winner.
   mock_server_->AddUpdatePref(ids_.FromNumber(201).GetServerId(), "", "tag c",
                               21, 210);
 
   mock_server_->set_conflict_all_commits(true);
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   // This should cause client tag overwrite.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry tag_a(&trans, GET_BY_CLIENT_TAG, "tag a");
     ASSERT_TRUE(tag_a.good());
     EXPECT_TRUE(tag_a.GetId().ServerKnows());
     EXPECT_EQ(ids_.FromNumber(1), tag_a.GetId());
     EXPECT_FALSE(tag_a.GetIsDel());
     EXPECT_FALSE(tag_a.GetIsUnappliedUpdate());
@@ skipping 31 matching lines @@
     ASSERT_EQ(3U, children.size());
   }
 }
 
 // This verifies transition to implicit permanent folders.
 TEST_F(SyncerTest, EntryWithParentIdUpdatedWithEntryWithoutParentId) {
   // Make sure SPECIFICS root exists so that we can get its parent ID.
   mock_server_->AddUpdateSpecifics(1, 0, "Folder", 10, 10, true, 1,
                                    DefaultPreferencesSpecifics());
   mock_server_->SetLastUpdateServerTag(ModelTypeToRootTag(PREFERENCES));
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   Id pref_root_id;
   {
     // Preferences type root should have been created by the update above.
     // We need it in order to get its ID.
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry pref_root(&trans, GET_TYPE_ROOT, PREFERENCES);
     ASSERT_TRUE(pref_root.good());
     pref_root_id = pref_root.GetId();
   }
 
   // Add a preference item with explicit parent ID.
   mock_server_->AddUpdatePref(ids_.FromNumber(2).GetServerId(),
                               ids_.FromNumber(1).GetServerId(), "tag", 1, 10);
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry pref_entry(&trans, GET_BY_CLIENT_TAG, "tag");
     ASSERT_TRUE(pref_entry.good());
     ASSERT_EQ(pref_root_id, pref_entry.GetParentId());
   }
 
   // Make another update where the same item get updated, this time
   // with implicit parent ID.
   mock_server_->AddUpdatePref(ids_.FromNumber(2).GetServerId(), "", "tag", 2,
                               20);
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry pref_entry(&trans, GET_BY_CLIENT_TAG, "tag");
     ASSERT_TRUE(pref_entry.good());
     ASSERT_TRUE(pref_entry.GetParentId().IsNull());
 
     // Verify that there is still one node under the type root.
     syncable::Directory::Metahandles children;
     directory()->GetChildHandlesById(&trans, pref_root_id, &children);
@@ skipping 20 matching lines @@
     EXPECT_FALSE(tag_bob.good());
   }
 
   // Now download some tagged items as updates.
   mock_server_->AddUpdateDirectory(
       1, 0, "update1", 1, 10, std::string(), std::string());
   mock_server_->SetLastUpdateServerTag("alpha");
   mock_server_->AddUpdateDirectory(
       2, 0, "update2", 2, 20, std::string(), std::string());
   mock_server_->SetLastUpdateServerTag("bob");
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     // The new items should be applied as new entries, and we should be able
     // to look them up by their tag values.
     Entry tag_alpha(&trans, GET_BY_SERVER_TAG, "alpha");
     ASSERT_TRUE(tag_alpha.good());
     ASSERT_TRUE(!tag_alpha.GetIsDel());
     ASSERT_TRUE(tag_alpha.GetUniqueServerTag()== "alpha");
@@ skipping 10 matching lines @@
     ASSERT_TRUE(hurdle.GetUniqueServerTag().empty());
     ASSERT_TRUE(hurdle.GetNonUniqueName()== "bob");
   }
 }
 
 TEST_F(SyncerTest, GetUpdatesSetsRequestedTypes) {
   // The expectations of this test happen in the MockConnectionManager's
   // GetUpdates handler.  EnableDatatype sets the expectation value from our
   // set of enabled/disabled datatypes.
   EnableDatatype(BOOKMARKS);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
   EnableDatatype(AUTOFILL);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
   EnableDatatype(PREFERENCES);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
   DisableDatatype(BOOKMARKS);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
   DisableDatatype(AUTOFILL);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
   DisableDatatype(PREFERENCES);
   EnableDatatype(AUTOFILL);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 }
 
 // A typical scenario: server and client each have one update for the other.
 // This is the "happy path" alternative to UpdateFailsThenDontCommit.
 TEST_F(SyncerTest, UpdateThenCommit) {
   syncable::Id to_receive = ids_.NewServerId();
   syncable::Id to_commit = ids_.NewLocalId();
 
   mock_server_->AddUpdateDirectory(to_receive, ids_.root(), "x", 1, 10,
                                    foreign_cache_guid(), "-1");
   int64 commit_handle = CreateUnsyncedDirectory("y", to_commit);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // The sync cycle should have included a GetUpdate, then a commit.  By the
   // time the commit happened, we should have known for sure that there were no
   // hierarchy conflicts, and reported this fact to the server.
   ASSERT_TRUE(mock_server_->last_request().has_commit());
   VerifyNoHierarchyConflictsReported(mock_server_->last_request());
 
   syncable::ReadTransaction trans(FROM_HERE, directory());
 
   Entry received(&trans, GET_BY_ID, to_receive);
@@ skipping 11 matching lines @@
 // We should not attempt to commit anything unless we successfully downloaded
 // updates, otherwise we risk causing a server-side conflict.
 TEST_F(SyncerTest, UpdateFailsThenDontCommit) {
   syncable::Id to_receive = ids_.NewServerId();
   syncable::Id to_commit = ids_.NewLocalId();
 
   mock_server_->AddUpdateDirectory(to_receive, ids_.root(), "x", 1, 10,
                                    foreign_cache_guid(), "-1");
   int64 commit_handle = CreateUnsyncedDirectory("y", to_commit);
   mock_server_->FailNextPostBufferToPathCall();
-  EXPECT_FALSE(SyncShareNudge());
+  SyncShareNudge();
 
   syncable::ReadTransaction trans(FROM_HERE, directory());
 
   // We did not receive this update.
   Entry received(&trans, GET_BY_ID, to_receive);
   ASSERT_FALSE(received.good());
 
   // And our local update remains unapplied.
   Entry committed(&trans, GET_BY_HANDLE, commit_handle);
   ASSERT_TRUE(committed.good());
@@ skipping 263 matching lines @@
   }
 
  protected:
   syncable::Id local_id_;
   int64 metahandle_;
 };
 
 TEST_F(SyncerBookmarksTest, CreateSyncThenDeleteSync) {
   Create();
   ExpectUnsyncedCreation();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ExpectSyncedAndCreated();
   Delete();
   ExpectUnsyncedDeletion();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ExpectSyncedAndDeleted();
 }
 
 TEST_F(SyncerBookmarksTest, CreateThenDeleteBeforeSync) {
   Create();
   ExpectUnsyncedCreation();
   Delete();
 
   // Deleting before the initial commit should result in not needing to send
   // the delete to the server. It will still be in an unsynced state, but with
   // IS_UNSYNCED set to false.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
 
     EXPECT_EQ(metahandle_, entry.GetMetahandle());
     EXPECT_TRUE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetServerIsDel());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_EQ(entry.GetBaseVersion(), -1);
     EXPECT_EQ(entry.GetServerVersion(), 0);
   }
 }
 
 TEST_F(SyncerBookmarksTest, LocalDeleteRemoteChangeConflict) {
   Create();
   ExpectUnsyncedCreation();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ExpectSyncedAndCreated();
   Delete();
   ExpectUnsyncedDeletion();
 
   // Trigger a getupdates that modifies the bookmark. The update should  be
   // clobbered by the local delete.
   mock_server_->AddUpdateBookmark(GetServerId(), Id::GetRoot(), "dummy", 10, 10,
                                   local_cache_guid(), local_id_.GetServerId());
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ExpectSyncedAndDeleted();
 }
 
 TEST_F(SyncerBookmarksTest, CreateThenDeleteDuringCommit) {
   Create();
   ExpectUnsyncedCreation();
 
   // In the middle of the initial creation commit, perform a deletion.
   // This should trigger performing two consecutive commit cycles, resulting
   // in the bookmark being both deleted and synced.
   mock_server_->SetMidCommitCallback(
       base::Bind(&SyncerBookmarksTest::Delete, base::Unretained(this)));
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ExpectSyncedAndDeleted();
 }
 
 TEST_F(SyncerBookmarksTest, CreateThenUpdateAndDeleteDuringCommit) {
   Create();
   ExpectUnsyncedCreation();
 
   // In the middle of the initial creation commit, perform an updated followed
   // by a deletion. This should trigger performing two consecutive commit
   // cycles, resulting in the bookmark being both deleted and synced.
   mock_server_->SetMidCommitCallback(base::Bind(
       &SyncerBookmarksTest::UpdateAndDelete, base::Unretained(this)));
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   ExpectSyncedAndDeleted();
 }
 
 // Test what happens if a client deletes, then recreates, an object very
 // quickly.  It is possible that the deletion gets sent as a commit, and
 // the undelete happens during the commit request.  The principle here
 // is that with a single committing client, conflicts should never
 // be encountered, and a client encountering its past actions during
 // getupdates should never feed back to override later actions.
 //
@@ skipping 146 matching lines @@
 
  protected:
   const std::string client_tag_;
   syncable::Id local_id_;
   int64 metahandle_;
 };
 
 TEST_F(SyncerUndeletionTest, UndeleteDuringCommit) {
   Create();
   ExpectUnsyncedCreation();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete, begin committing the delete, then undelete while committing.
   Delete();
   ExpectUnsyncedDeletion();
   mock_server_->SetMidCommitCallback(
       base::Bind(&SyncerUndeletionTest::Undelete, base::Unretained(this)));
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // We will continue to commit until all nodes are synced, so we expect
   // that both the delete and following undelete were committed.  We haven't
   // downloaded any updates, though, so the SERVER fields will be the same
   // as they were at the start of the cycle.
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
@@ skipping 10 matching lines @@
 
   // Now, encounter a GetUpdates corresponding to the deletion from
   // the server.  The undeletion should prevail again and be committed.
   // None of this should trigger any conflict detection -- it is perfectly
   // normal to recieve updates from our own commits.
   mock_server_->SetMidCommitCallback(base::Closure());
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   update->set_originator_client_item_id(local_id_.GetServerId());
 
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteBeforeCommit) {
   Create();
   ExpectUnsyncedCreation();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete and undelete, then sync to pick up the result.
   Delete();
   ExpectUnsyncedDeletion();
   Undelete();
   ExpectUnsyncedEdit();  // Edit, not undelete: server thinks it exists.
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // The item ought to have committed successfully.
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     EXPECT_EQ(2, entry.GetBaseVersion());
   }
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // update.
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   update->set_originator_client_item_id(local_id_.GetServerId());
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteAfterCommitButBeforeGetUpdates) {
   Create();
   ExpectUnsyncedCreation();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete and commit.
   Delete();
   ExpectUnsyncedDeletion();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // The item ought to have committed successfully.
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Before the GetUpdates, the item is locally undeleted.
   Undelete();
   ExpectUnsyncedUndeletion();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
   mock_server_->AddUpdateFromLastCommit();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteAfterDeleteAndGetUpdates) {
   Create();
   ExpectUnsyncedCreation();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   update->set_originator_client_item_id(local_id_.GetServerId());
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete and commit.
   Delete();
   ExpectUnsyncedDeletion();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // The item ought to have committed successfully.
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  Should be consistent.
   mock_server_->AddUpdateFromLastCommit();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // After the GetUpdates, the item is locally undeleted.
   Undelete();
   ExpectUnsyncedUndeletion();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 // Test processing of undeletion GetUpdateses.
 TEST_F(SyncerUndeletionTest, UndeleteAfterOtherClientDeletes) {
   Create();
   ExpectUnsyncedCreation();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Add a delete from the server.
   sync_pb::SyncEntity* update1 = mock_server_->AddUpdateFromLastCommit();
   update1->set_originator_cache_guid(local_cache_guid());
   update1->set_originator_client_item_id(local_id_.GetServerId());
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Some other client deletes the item.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     mock_server_->AddUpdateTombstone(entry.GetId(), PREFERENCES);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // The update ought to have applied successfully.
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Undelete it locally.
   Undelete();
   ExpectUnsyncedUndeletion();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
   sync_pb::SyncEntity* update2 = mock_server_->AddUpdateFromLastCommit();
   update2->set_originator_cache_guid(local_cache_guid());
   update2->set_originator_client_item_id(local_id_.GetServerId());
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteAfterOtherClientDeletesImmediately) {
   Create();
   ExpectUnsyncedCreation();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Some other client deletes the item before we get a chance
   // to GetUpdates our original request.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     mock_server_->AddUpdateTombstone(entry.GetId(), PREFERENCES);
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // The update ought to have applied successfully.
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Undelete it locally.
   Undelete();
   ExpectUnsyncedUndeletion();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   update->set_originator_client_item_id(local_id_.GetServerId());
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, OtherClientUndeletes) {
   Create();
   ExpectUnsyncedCreation();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Get the updates of our just-committed entry.
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   update->set_originator_client_item_id(local_id_.GetServerId());
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // We delete the item.
   Delete();
   ExpectUnsyncedDeletion();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // The update ought to have applied successfully.
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.
   mock_server_->AddUpdateFromLastCommit();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Some other client undeletes the item.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     mock_server_->AddUpdatePref(
         entry.GetId().GetServerId(),
         entry.GetParentId().GetServerId(),
         client_tag_, 100, 1000);
   }
   mock_server_->SetLastUpdateClientTag(client_tag_);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, OtherClientUndeletesImmediately) {
   Create();
   ExpectUnsyncedCreation();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Get the updates of our just-committed entry.
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     update->set_originator_client_item_id(local_id_.GetServerId());
   }
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // We delete the item.
   Delete();
   ExpectUnsyncedDeletion();
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
 
   // The update ought to have applied successfully.
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Some other client undeletes before we see the update from our
   // commit.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     mock_server_->AddUpdatePref(
         entry.GetId().GetServerId(),
         entry.GetParentId().GetServerId(),
         client_tag_, 100, 1000);
   }
   mock_server_->SetLastUpdateClientTag(client_tag_);
-  EXPECT_TRUE(SyncShareNudge());
+  SyncShareNudge();
   EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 enum {
   TEST_PARAM_BOOKMARK_ENABLE_BIT,
   TEST_PARAM_AUTOFILL_ENABLE_BIT,
   TEST_PARAM_BIT_COUNT
 };
@@ skipping 40 matching lines @@
   // Put some extenions activity records into the monitor.
   {
     ExtensionsActivity::Records records;
     records["ABC"].extension_id = "ABC";
     records["ABC"].bookmark_write_count = 2049U;
     records["xyz"].extension_id = "xyz";
     records["xyz"].bookmark_write_count = 4U;
     context_->extensions_activity()->PutRecords(records);
   }
 
-  EXPECT_EQ(!ShouldFailBookmarkCommit() && !ShouldFailAutofillCommit(),
-            SyncShareNudge());
+  SyncShareNudge();
 
   ExtensionsActivity::Records final_monitor_records;
   context_->extensions_activity()->GetAndClearRecords(&final_monitor_records);
   if (ShouldFailBookmarkCommit()) {
     ASSERT_EQ(2U, final_monitor_records.size())
         << "Should restore records after unsuccessful bookmark commit.";
     EXPECT_EQ("ABC", final_monitor_records["ABC"].extension_id);
     EXPECT_EQ("xyz", final_monitor_records["xyz"].extension_id);
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U,    final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 }  // namespace syncer