[Sync] Move 'sync' target to sync/

chrome/browser/sync/engine/syncer_unittest.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// Syncer unit tests. Unfortunately a lot of these tests
-// are outdated and need to be reworked and updated.
-
-#include <algorithm>
-#include <limits>
-#include <list>
-#include <map>
-#include <set>
-#include <string>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/location.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/message_loop.h"
-#include "base/string_number_conversions.h"
-#include "base/stringprintf.h"
-#include "base/time.h"
-#include "build/build_config.h"
-#include "chrome/browser/sync/engine/get_commit_ids_command.h"
-#include "chrome/browser/sync/engine/model_safe_worker.h"
-#include "chrome/browser/sync/engine/net/server_connection_manager.h"
-#include "chrome/browser/sync/engine/nigori_util.h"
-#include "chrome/browser/sync/engine/process_updates_command.h"
-#include "chrome/browser/sync/engine/syncer.h"
-#include "chrome/browser/sync/engine/syncer_proto_util.h"
-#include "chrome/browser/sync/engine/syncer_util.h"
-#include "chrome/browser/sync/engine/syncproto.h"
-#include "chrome/browser/sync/sessions/sync_session_context.h"
-#include "chrome/browser/sync/syncable/model_type.h"
-#include "chrome/browser/sync/syncable/syncable.h"
-#include "chrome/browser/sync/test/engine/fake_model_worker.h"
-#include "chrome/browser/sync/test/engine/mock_connection_manager.h"
-#include "chrome/browser/sync/test/engine/test_directory_setter_upper.h"
-#include "chrome/browser/sync/test/engine/test_id_factory.h"
-#include "chrome/browser/sync/test/engine/test_syncable_utils.h"
-#include "chrome/browser/sync/test/fake_encryptor.h"
-#include "chrome/browser/sync/test/fake_extensions_activity_monitor.h"
-#include "chrome/browser/sync/util/cryptographer.h"
-#include "chrome/browser/sync/util/time.h"
-#include "sync/protocol/bookmark_specifics.pb.h"
-#include "sync/protocol/nigori_specifics.pb.h"
-#include "sync/protocol/preference_specifics.pb.h"
-#include "sync/protocol/sync.pb.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using base::TimeDelta;
-
-using std::map;
-using std::multimap;
-using std::set;
-using std::string;
-
-namespace browser_sync {
-
-using syncable::BaseTransaction;
-using syncable::Blob;
-using syncable::CountEntriesWithName;
-using syncable::Directory;
-using syncable::Entry;
-using syncable::GetFirstEntryWithName;
-using syncable::GetOnlyEntryWithName;
-using syncable::Id;
-using syncable::kEncryptedString;
-using syncable::MutableEntry;
-using syncable::ReadTransaction;
-using syncable::WriteTransaction;
-
-using syncable::BASE_VERSION;
-using syncable::CREATE;
-using syncable::CREATE_NEW_UPDATE_ITEM;
-using syncable::GET_BY_HANDLE;
-using syncable::GET_BY_ID;
-using syncable::GET_BY_CLIENT_TAG;
-using syncable::GET_BY_SERVER_TAG;
-using syncable::ID;
-using syncable::IS_DEL;
-using syncable::IS_DIR;
-using syncable::IS_UNAPPLIED_UPDATE;
-using syncable::IS_UNSYNCED;
-using syncable::META_HANDLE;
-using syncable::MTIME;
-using syncable::NEXT_ID;
-using syncable::NON_UNIQUE_NAME;
-using syncable::PARENT_ID;
-using syncable::PREV_ID;
-using syncable::BASE_SERVER_SPECIFICS;
-using syncable::SERVER_IS_DEL;
-using syncable::SERVER_NON_UNIQUE_NAME;
-using syncable::SERVER_PARENT_ID;
-using syncable::SERVER_POSITION_IN_PARENT;
-using syncable::SERVER_SPECIFICS;
-using syncable::SERVER_VERSION;
-using syncable::UNIQUE_CLIENT_TAG;
-using syncable::UNIQUE_SERVER_TAG;
-using syncable::SPECIFICS;
-using syncable::SYNCING;
-using syncable::UNITTEST;
-
-using sessions::ConflictProgress;
-using sessions::ScopedSetSessionWriteTransaction;
-using sessions::StatusController;
-using sessions::SyncSessionContext;
-using sessions::SyncSession;
-
-class SyncerTest : public testing::Test,
-                   public SyncSession::Delegate,
-                   public ModelSafeWorkerRegistrar,
-                   public SyncEngineEventListener {
- protected:
-  SyncerTest() : syncer_(NULL), saw_syncer_event_(false) {}
-
-  // SyncSession::Delegate implementation.
-  virtual void OnSilencedUntil(const base::TimeTicks& silenced_until) OVERRIDE {
-    FAIL() << "Should not get silenced.";
-  }
-  virtual bool IsSyncingCurrentlySilenced() OVERRIDE {
-    return false;
-  }
-  virtual void OnReceivedLongPollIntervalUpdate(
-      const base::TimeDelta& new_interval) OVERRIDE {
-    last_long_poll_interval_received_ = new_interval;
-  }
-  virtual void OnReceivedShortPollIntervalUpdate(
-      const base::TimeDelta& new_interval) OVERRIDE {
-    last_short_poll_interval_received_ = new_interval;
-  }
-  virtual void OnReceivedSessionsCommitDelay(
-      const base::TimeDelta& new_delay) OVERRIDE {
-    last_sessions_commit_delay_seconds_ = new_delay;
-  }
-  virtual void OnShouldStopSyncingPermanently() OVERRIDE {
-  }
-  virtual void OnSyncProtocolError(
-      const sessions::SyncSessionSnapshot& snapshot) OVERRIDE {
-  }
-
-  // ModelSafeWorkerRegistrar implementation.
-  virtual void GetWorkers(std::vector<ModelSafeWorker*>* out) OVERRIDE {
-    out->push_back(worker_.get());
-  }
-
-  virtual void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) OVERRIDE {
-    // We're just testing the sync engine here, so we shunt everything to
-    // the SyncerThread.  Datatypes which aren't enabled aren't in the map.
-    for (syncable::ModelTypeSet::Iterator it = enabled_datatypes_.First();
-         it.Good(); it.Inc()) {
-      (*out)[it.Get()] = GROUP_PASSIVE;
-    }
-  }
-
-  virtual void OnSyncEngineEvent(const SyncEngineEvent& event) OVERRIDE {
-    DVLOG(1) << "HandleSyncEngineEvent in unittest " << event.what_happened;
-    // we only test for entry-specific events, not status changed ones.
-    switch (event.what_happened) {
-      case SyncEngineEvent::SYNC_CYCLE_BEGIN: // Fall through.
-      case SyncEngineEvent::STATUS_CHANGED:
-      case SyncEngineEvent::SYNC_CYCLE_ENDED:
-        return;
-      default:
-        CHECK(false) << "Handling unknown error type in unit tests!!";
-    }
-    saw_syncer_event_ = true;
-  }
-
-  SyncSession* MakeSession() {
-    ModelSafeRoutingInfo info;
-    std::vector<ModelSafeWorker*> workers;
-    GetModelSafeRoutingInfo(&info);
-    GetWorkers(&workers);
-    syncable::ModelTypePayloadMap types =
-        syncable::ModelTypePayloadMapFromRoutingInfo(info, std::string());
-    return new SyncSession(context_.get(), this,
-        sessions::SyncSourceInfo(sync_pb::GetUpdatesCallerInfo::UNKNOWN, types),
-        info, workers);
-  }
-
-  bool SyncShareAsDelegate() {
-    session_.reset(MakeSession());
-    syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-    return session_->HasMoreToSync();
-  }
-
-  void LoopSyncShare() {
-    bool should_loop = false;
-    int loop_iterations = 0;
-    do {
-      ASSERT_LT(++loop_iterations, 100) << "infinite loop detected. please fix";
-      should_loop = SyncShareAsDelegate();
-    } while (should_loop);
-  }
-
-  virtual void SetUp() {
-    dir_maker_.SetUp();
-    mock_server_.reset(new MockConnectionManager(directory()));
-    EnableDatatype(syncable::BOOKMARKS);
-    EnableDatatype(syncable::NIGORI);
-    EnableDatatype(syncable::PREFERENCES);
-    EnableDatatype(syncable::NIGORI);
-    worker_ = new FakeModelWorker(GROUP_PASSIVE);
-    std::vector<SyncEngineEventListener*> listeners;
-    listeners.push_back(this);
-    context_.reset(
-        new SyncSessionContext(
-            mock_server_.get(), directory(), this,
-            &extensions_activity_monitor_, listeners, NULL));
-    ASSERT_FALSE(context_->resolver());
-    syncer_ = new Syncer();
-    session_.reset(MakeSession());
-
-    ReadTransaction trans(FROM_HERE, directory());
-    syncable::Directory::ChildHandles children;
-    directory()->GetChildHandlesById(&trans, trans.root_id(), &children);
-    ASSERT_EQ(0u, children.size());
-    saw_syncer_event_ = false;
-    root_id_ = TestIdFactory::root();
-    parent_id_ = ids_.MakeServer("parent id");
-    child_id_ = ids_.MakeServer("child id");
-  }
-
-  virtual void TearDown() {
-    mock_server_.reset();
-    delete syncer_;
-    syncer_ = NULL;
-    dir_maker_.TearDown();
-  }
-  void WriteTestDataToEntry(WriteTransaction* trans, MutableEntry* entry) {
-    EXPECT_FALSE(entry->Get(IS_DIR));
-    EXPECT_FALSE(entry->Get(IS_DEL));
-    sync_pb::EntitySpecifics specifics;
-    specifics.mutable_bookmark()->set_url("http://demo/");
-    specifics.mutable_bookmark()->set_favicon("PNG");
-    entry->Put(syncable::SPECIFICS, specifics);
-    entry->Put(syncable::IS_UNSYNCED, true);
-  }
-  void VerifyTestDataInEntry(BaseTransaction* trans, Entry* entry) {
-    EXPECT_FALSE(entry->Get(IS_DIR));
-    EXPECT_FALSE(entry->Get(IS_DEL));
-    VerifyTestBookmarkDataInEntry(entry);
-  }
-  void VerifyTestBookmarkDataInEntry(Entry* entry) {
-    const sync_pb::EntitySpecifics& specifics = entry->Get(syncable::SPECIFICS);
-    EXPECT_TRUE(specifics.has_bookmark());
-    EXPECT_EQ("PNG", specifics.bookmark().favicon());
-    EXPECT_EQ("http://demo/", specifics.bookmark().url());
-  }
-
-  void SyncRepeatedlyToTriggerConflictResolution(SyncSession* session) {
-    // We should trigger after less than 6 syncs, but extra does no harm.
-    for (int i = 0 ; i < 6 ; ++i)
-      syncer_->SyncShare(session, SYNCER_BEGIN, SYNCER_END);
-  }
-  void SyncRepeatedlyToTriggerStuckSignal(SyncSession* session) {
-    // We should trigger after less than 10 syncs, but we want to avoid brittle
-    // tests.
-    for (int i = 0 ; i < 12 ; ++i)
-      syncer_->SyncShare(session, SYNCER_BEGIN, SYNCER_END);
-  }
-  sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
-    sync_pb::EntitySpecifics result;
-    AddDefaultFieldValue(syncable::BOOKMARKS, &result);
-    return result;
-  }
-
-  sync_pb::EntitySpecifics DefaultPreferencesSpecifics() {
-    sync_pb::EntitySpecifics result;
-    AddDefaultFieldValue(syncable::PREFERENCES, &result);
-    return result;
-  }
-  // Enumeration of alterations to entries for commit ordering tests.
-  enum EntryFeature {
-    LIST_END = 0,  // Denotes the end of the list of features from below.
-    SYNCED,  // Items are unsynced by default
-    DELETED,
-    OLD_MTIME,
-    MOVED_FROM_ROOT,
-  };
-
-  struct CommitOrderingTest {
-    // expected commit index.
-    int commit_index;
-    // Details about the item
-    syncable::Id id;
-    syncable::Id parent_id;
-    EntryFeature features[10];
-
-    static const CommitOrderingTest LAST_COMMIT_ITEM;
-  };
-
-  void RunCommitOrderingTest(CommitOrderingTest* test) {
-    map<int, syncable::Id> expected_positions;
-    {  // Transaction scope.
-      WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-      while (!test->id.IsRoot()) {
-        if (test->commit_index >= 0) {
-          map<int, syncable::Id>::value_type entry(test->commit_index,
-                                                   test->id);
-          bool double_position = !expected_positions.insert(entry).second;
-          ASSERT_FALSE(double_position) << "Two id's expected at one position";
-        }
-        string utf8_name = test->id.GetServerId();
-        string name(utf8_name.begin(), utf8_name.end());
-        MutableEntry entry(&trans, CREATE, test->parent_id, name);
-
-        entry.Put(syncable::ID, test->id);
-        if (test->id.ServerKnows()) {
-          entry.Put(BASE_VERSION, 5);
-          entry.Put(SERVER_VERSION, 5);
-          entry.Put(SERVER_PARENT_ID, test->parent_id);
-        }
-        entry.Put(syncable::IS_DIR, true);
-        entry.Put(syncable::IS_UNSYNCED, true);
-        entry.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-        // Set the time to 30 seconds in the future to reduce the chance of
-        // flaky tests.
-        const base::Time& now_plus_30s =
-            base::Time::Now() + base::TimeDelta::FromSeconds(30);
-        const base::Time& now_minus_2h =
-            base::Time::Now() - base::TimeDelta::FromHours(2);
-        entry.Put(syncable::MTIME, now_plus_30s);
-        for (size_t i = 0 ; i < arraysize(test->features) ; ++i) {
-          switch (test->features[i]) {
-            case LIST_END:
-              break;
-            case SYNCED:
-              entry.Put(syncable::IS_UNSYNCED, false);
-              break;
-            case DELETED:
-              entry.Put(syncable::IS_DEL, true);
-              break;
-            case OLD_MTIME:
-              entry.Put(MTIME, now_minus_2h);
-              break;
-            case MOVED_FROM_ROOT:
-              entry.Put(SERVER_PARENT_ID, trans.root_id());
-              break;
-            default:
-              FAIL() << "Bad value in CommitOrderingTest list";
-          }
-        }
-        test++;
-      }
-    }
-    LoopSyncShare();
-    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) {
-      EXPECT_EQ(1u, expected_positions.count(i));
-      EXPECT_TRUE(expected_positions[i] == mock_server_->committed_ids()[i]);
-    }
-  }
-
-  void DoTruncationTest(const vector<int64>& unsynced_handle_view,
-                        const vector<syncable::Id>& expected_id_order) {
-    for (size_t limit = expected_id_order.size() + 2; limit > 0; --limit) {
-      StatusController* status = session_->mutable_status_controller();
-      WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-      ScopedSetSessionWriteTransaction set_trans(session_.get(), &wtrans);
-
-      ModelSafeRoutingInfo routes;
-      GetModelSafeRoutingInfo(&routes);
-      GetCommitIdsCommand command(limit);
-      std::set<int64> ready_unsynced_set;
-      command.FilterUnreadyEntries(&wtrans, syncable::ModelTypeSet(),
-                                   syncable::ModelTypeSet(), false,
-                                   unsynced_handle_view, &ready_unsynced_set);
-      command.BuildCommitIds(session_->write_transaction(), routes,
-                             ready_unsynced_set);
-      syncable::Directory::UnsyncedMetaHandles ready_unsynced_vector(
-        ready_unsynced_set.begin(), ready_unsynced_set.end());
-      status->set_unsynced_handles(ready_unsynced_vector);
-      vector<syncable::Id> output =
-          command.ordered_commit_set_->GetAllCommitIds();
-      size_t truncated_size = std::min(limit, expected_id_order.size());
-      ASSERT_EQ(truncated_size, output.size());
-      for (size_t i = 0; i < truncated_size; ++i) {
-        ASSERT_EQ(expected_id_order[i], output[i])
-            << "At index " << i << " with batch size limited to " << limit;
-      }
-      sessions::OrderedCommitSet::Projection proj;
-      proj = command.ordered_commit_set_->GetCommitIdProjection(GROUP_PASSIVE);
-      ASSERT_EQ(truncated_size, proj.size());
-      for (size_t i = 0; i < truncated_size; ++i) {
-        SCOPED_TRACE(::testing::Message("Projection mismatch with i = ") << i);
-        syncable::Id projected =
-            command.ordered_commit_set_->GetCommitIdAt(proj[i]);
-        ASSERT_EQ(expected_id_order[proj[i]], projected);
-        // Since this projection is the identity, the following holds.
-        ASSERT_EQ(expected_id_order[i], projected);
-      }
-    }
-  }
-
-  Directory* directory() {
-    return dir_maker_.directory();
-  }
-
-  int64 CreateUnsyncedDirectory(const string& entry_name,
-      const string& idstring) {
-    return CreateUnsyncedDirectory(entry_name,
-        syncable::Id::CreateFromServerId(idstring));
-  }
-
-  int64 CreateUnsyncedDirectory(const string& entry_name,
-      const syncable::Id& id) {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&wtrans, syncable::CREATE, wtrans.root_id(),
-                       entry_name);
-    EXPECT_TRUE(entry.good());
-    entry.Put(syncable::IS_UNSYNCED, true);
-    entry.Put(syncable::IS_DIR, true);
-    entry.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    entry.Put(syncable::BASE_VERSION, id.ServerKnows() ? 1 : 0);
-    entry.Put(syncable::ID, id);
-    return entry.Get(META_HANDLE);
-  }
-
-  void EnableDatatype(syncable::ModelType model_type) {
-    enabled_datatypes_.Put(model_type);
-    mock_server_->ExpectGetUpdatesRequestTypes(enabled_datatypes_);
-  }
-
-  void DisableDatatype(syncable::ModelType model_type) {
-    enabled_datatypes_.Remove(model_type);
-    mock_server_->ExpectGetUpdatesRequestTypes(enabled_datatypes_);
-  }
-
-  template<typename FieldType, typename ValueType>
-  ValueType GetField(int64 metahandle, FieldType field,
-      ValueType default_value) {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_HANDLE, metahandle);
-    EXPECT_TRUE(entry.good());
-    if (!entry.good()) {
-      return default_value;
-    }
-    EXPECT_EQ(metahandle, entry.Get(META_HANDLE));
-    return entry.Get(field);
-  }
-
-  // Helper getters that work without a transaction, to reduce boilerplate.
-  Id Get(int64 metahandle, syncable::IdField field) {
-    return GetField(metahandle, field, syncable::GetNullId());
-  }
-
-  string Get(int64 metahandle, syncable::StringField field) {
-    return GetField(metahandle, field, string());
-  }
-
-  int64 Get(int64 metahandle, syncable::Int64Field field) {
-    return GetField(metahandle, field, syncable::kInvalidMetaHandle);
-  }
-
-  int64 Get(int64 metahandle, syncable::BaseVersion field) {
-    const int64 kDefaultValue = -100;
-    return GetField(metahandle, field, kDefaultValue);
-  }
-
-  bool Get(int64 metahandle, syncable::IndexedBitField field) {
-    return GetField(metahandle, field, false);
-  }
-
-  bool Get(int64 metahandle, syncable::IsDelField field) {
-    return GetField(metahandle, field, false);
-  }
-
-  bool Get(int64 metahandle, syncable::BitField field) {
-    return GetField(metahandle, field, false);
-  }
-
-  Cryptographer* cryptographer(syncable::BaseTransaction* trans) {
-    return directory()->GetCryptographer(trans);
-  }
-
-  MessageLoop message_loop_;
-
-  // Some ids to aid tests. Only the root one's value is specific. The rest
-  // are named for test clarity.
-  // TODO(chron): Get rid of these inbuilt IDs. They only make it
-  // more confusing.
-  syncable::Id root_id_;
-  syncable::Id parent_id_;
-  syncable::Id child_id_;
-
-  TestIdFactory ids_;
-
-  TestDirectorySetterUpper dir_maker_;
-  FakeEncryptor encryptor_;
-  FakeExtensionsActivityMonitor extensions_activity_monitor_;
-  scoped_ptr<MockConnectionManager> mock_server_;
-
-  Syncer* syncer_;
-
-  scoped_ptr<SyncSession> session_;
-  scoped_ptr<SyncSessionContext> context_;
-  bool saw_syncer_event_;
-  base::TimeDelta last_short_poll_interval_received_;
-  base::TimeDelta last_long_poll_interval_received_;
-  base::TimeDelta last_sessions_commit_delay_seconds_;
-  scoped_refptr<ModelSafeWorker> worker_;
-
-  syncable::ModelTypeSet enabled_datatypes_;
-
-  DISALLOW_COPY_AND_ASSIGN(SyncerTest);
-};
-
-TEST_F(SyncerTest, TestCallGatherUnsyncedEntries) {
-  {
-    Syncer::UnsyncedMetaHandles handles;
-    {
-      ReadTransaction trans(FROM_HERE, directory());
-      SyncerUtil::GetUnsyncedEntries(&trans, &handles);
-    }
-    ASSERT_EQ(0u, handles.size());
-  }
-  // TODO(sync): When we can dynamically connect and disconnect the mock
-  // ServerConnectionManager test disconnected GetUnsyncedEntries here. It's a
-  // regression for a very old bug.
-}
-
-TEST_F(SyncerTest, GetCommitIdsCommandTruncates) {
-  syncable::Id root = ids_.root();
-  // Create two server entries.
-  mock_server_->AddUpdateDirectory(ids_.MakeServer("x"), root, "X", 10, 10);
-  mock_server_->AddUpdateDirectory(ids_.MakeServer("w"), root, "W", 10, 10);
-  SyncShareAsDelegate();
-
-  // Create some new client entries.
-  CreateUnsyncedDirectory("C", ids_.MakeLocal("c"));
-  CreateUnsyncedDirectory("B", ids_.MakeLocal("b"));
-  CreateUnsyncedDirectory("D", ids_.MakeLocal("d"));
-  CreateUnsyncedDirectory("E", ids_.MakeLocal("e"));
-  CreateUnsyncedDirectory("J", ids_.MakeLocal("j"));
-
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry_x(&wtrans, GET_BY_ID, ids_.MakeServer("x"));
-    MutableEntry entry_b(&wtrans, GET_BY_ID, ids_.MakeLocal("b"));
-    MutableEntry entry_c(&wtrans, GET_BY_ID, ids_.MakeLocal("c"));
-    MutableEntry entry_d(&wtrans, GET_BY_ID, ids_.MakeLocal("d"));
-    MutableEntry entry_e(&wtrans, GET_BY_ID, ids_.MakeLocal("e"));
-    MutableEntry entry_w(&wtrans, GET_BY_ID, ids_.MakeServer("w"));
-    MutableEntry entry_j(&wtrans, GET_BY_ID, ids_.MakeLocal("j"));
-    entry_x.Put(IS_UNSYNCED, true);
-    entry_b.Put(PARENT_ID, entry_x.Get(ID));
-    entry_d.Put(PARENT_ID, entry_b.Get(ID));
-    entry_c.Put(PARENT_ID, entry_x.Get(ID));
-    entry_c.PutPredecessor(entry_b.Get(ID));
-    entry_e.Put(PARENT_ID, entry_c.Get(ID));
-    entry_w.PutPredecessor(entry_x.Get(ID));
-    entry_w.Put(IS_UNSYNCED, true);
-    entry_w.Put(SERVER_VERSION, 20);
-    entry_w.Put(IS_UNAPPLIED_UPDATE, true);  // Fake a conflict.
-    entry_j.PutPredecessor(entry_w.Get(ID));
-  }
-
-  // The arrangement is now: x (b (d) c (e)) w j
-  // Entry "w" is in conflict, making its sucessors unready to commit.
-  vector<int64> unsynced_handle_view;
-  vector<syncable::Id> expected_order;
-  {
-    ReadTransaction rtrans(FROM_HERE, directory());
-    SyncerUtil::GetUnsyncedEntries(&rtrans, &unsynced_handle_view);
-  }
-  // The expected order is "x", "b", "c", "d", "e", truncated appropriately.
-  expected_order.push_back(ids_.MakeServer("x"));
-  expected_order.push_back(ids_.MakeLocal("b"));
-  expected_order.push_back(ids_.MakeLocal("c"));
-  expected_order.push_back(ids_.MakeLocal("d"));
-  expected_order.push_back(ids_.MakeLocal("e"));
-  DoTruncationTest(unsynced_handle_view, expected_order);
-}
-
-TEST_F(SyncerTest, GetCommitIdsFiltersThrottledEntries) {
-  const syncable::ModelTypeSet throttled_types(syncable::BOOKMARKS);
-  sync_pb::EntitySpecifics bookmark_data;
-  AddDefaultFieldValue(syncable::BOOKMARKS, &bookmark_data);
-
-  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
-  SyncShareAsDelegate();
-
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(A.good());
-    A.Put(IS_UNSYNCED, true);
-    A.Put(SPECIFICS, bookmark_data);
-    A.Put(NON_UNIQUE_NAME, "bookmark");
-  }
-
-  // Now set the throttled types.
-  context_->SetUnthrottleTime(
-      throttled_types,
-      base::TimeTicks::Now() + base::TimeDelta::FromSeconds(1200));
-  SyncShareAsDelegate();
-
-  {
-    // Nothing should have been committed as bookmarks is throttled.
-    ReadTransaction rtrans(FROM_HERE, directory());
-    Entry entryA(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(entryA.good());
-    EXPECT_TRUE(entryA.Get(IS_UNSYNCED));
-  }
-
-  // Now unthrottle.
-  context_->SetUnthrottleTime(
-      throttled_types,
-      base::TimeTicks::Now() - base::TimeDelta::FromSeconds(1200));
-  SyncShareAsDelegate();
-  {
-    // It should have been committed.
-    ReadTransaction rtrans(FROM_HERE, directory());
-    Entry entryA(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(entryA.good());
-    EXPECT_FALSE(entryA.Get(IS_UNSYNCED));
-  }
-}
-
-// We use a macro so we can preserve the error location.
-#define VERIFY_ENTRY(id, is_unapplied, is_unsynced, prev_initialized, \
-                     parent_id, version, server_version, id_fac, rtrans) \
-  do { \
-    Entry entryA(rtrans, syncable::GET_BY_ID, id_fac.FromNumber(id)); \
-    ASSERT_TRUE(entryA.good()); \
-    /* We don't use EXPECT_EQ here because when the left side param is false,
-    gcc 4.6 warns about converting 'false' to pointer type for argument 1. */ \
-    EXPECT_TRUE(is_unsynced == entryA.Get(IS_UNSYNCED)); \
-    EXPECT_TRUE(is_unapplied == entryA.Get(IS_UNAPPLIED_UPDATE)); \
-    EXPECT_TRUE(prev_initialized == \
-              syncable::IsRealDataType(syncable::GetModelTypeFromSpecifics( \
-                  entryA.Get(BASE_SERVER_SPECIFICS)))); \
-    EXPECT_TRUE(parent_id == -1 || \
-                entryA.Get(PARENT_ID) == id_fac.FromNumber(parent_id)); \
-    EXPECT_EQ(version, entryA.Get(BASE_VERSION)); \
-    EXPECT_EQ(server_version, entryA.Get(SERVER_VERSION)); \
-  } while (0)
-
-TEST_F(SyncerTest, GetCommitIdsFiltersUnreadyEntries) {
-  KeyParams key_params = {"localhost", "dummy", "foobar"};
-  KeyParams other_params = {"localhost", "dummy", "foobar2"};
-  sync_pb::EntitySpecifics bookmark, encrypted_bookmark;
-  bookmark.mutable_bookmark()->set_url("url");
-  bookmark.mutable_bookmark()->set_title("title");
-  AddDefaultFieldValue(syncable::BOOKMARKS, &encrypted_bookmark);
-  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
-  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
-  mock_server_->AddUpdateDirectory(3, 0, "C", 10, 10);
-  mock_server_->AddUpdateDirectory(4, 0, "D", 10, 10);
-  SyncShareAsDelegate();
-  // Server side change will put A in conflict.
-  mock_server_->AddUpdateDirectory(1, 0, "A", 20, 20);
-  {
-    // Mark bookmarks as encrypted and set the cryptographer to have pending
-    // keys.
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    browser_sync::Cryptographer other_cryptographer(&encryptor_);
-    other_cryptographer.AddKey(other_params);
-    sync_pb::EntitySpecifics specifics;
-    sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
-    other_cryptographer.GetKeys(nigori->mutable_encrypted());
-    nigori->set_encrypt_bookmarks(true);
-    // Set up with an old passphrase, but have pending keys
-    cryptographer(&wtrans)->AddKey(key_params);
-    cryptographer(&wtrans)->Encrypt(bookmark,
-                                    encrypted_bookmark.mutable_encrypted());
-    cryptographer(&wtrans)->Update(*nigori);
-
-    // In conflict but properly encrypted.
-    MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(A.good());
-    A.Put(IS_UNSYNCED, true);
-    A.Put(SPECIFICS, encrypted_bookmark);
-    A.Put(NON_UNIQUE_NAME, kEncryptedString);
-    // Not in conflict and properly encrypted.
-    MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(B.good());
-    B.Put(IS_UNSYNCED, true);
-    B.Put(SPECIFICS, encrypted_bookmark);
-    B.Put(NON_UNIQUE_NAME, kEncryptedString);
-    // Unencrypted specifics.
-    MutableEntry C(&wtrans, GET_BY_ID, ids_.FromNumber(3));
-    ASSERT_TRUE(C.good());
-    C.Put(IS_UNSYNCED, true);
-    C.Put(NON_UNIQUE_NAME, kEncryptedString);
-    // Unencrypted non_unique_name.
-    MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
-    ASSERT_TRUE(D.good());
-    D.Put(IS_UNSYNCED, true);
-    D.Put(SPECIFICS, encrypted_bookmark);
-    D.Put(NON_UNIQUE_NAME, "not encrypted");
-  }
-  SyncShareAsDelegate();
-  {
-    // We remove any unready entries from the status controller's unsynced
-    // handles, so this should remain 0 even though the entries didn't commit.
-    EXPECT_EQ(0U, session_->status_controller().unsynced_handles().size());
-    // 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.
-    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.
-    cryptographer(&rtrans)->DecryptPendingKeys(other_params);
-  }
-  SyncShareAsDelegate();
-  {
-    // 2 unsynced handles to reflect the items that committed succesfully.
-    EXPECT_EQ(2U, session_->status_controller().unsynced_handles().size());
-    // 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.
-    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.Put(SPECIFICS, encrypted_bookmark);
-    C.Put(NON_UNIQUE_NAME, kEncryptedString);
-    MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
-    ASSERT_TRUE(D.good());
-    D.Put(SPECIFICS, encrypted_bookmark);
-    D.Put(NON_UNIQUE_NAME, kEncryptedString);
-  }
-  SyncShareAsDelegate();
-  {
-    // We attempted to commit two items.
-    EXPECT_EQ(2U, session_->status_controller().unsynced_handles().size());
-    EXPECT_TRUE(session_->status_controller().did_commit_items());
-    // None should be unsynced anymore.
-    ReadTransaction rtrans(FROM_HERE, directory());
-    VERIFY_ENTRY(1, false, false, false, 0, 21, 21, ids_, &rtrans);
-    VERIFY_ENTRY(2, false, false, false, 0, 11, 11, ids_, &rtrans);
-    VERIFY_ENTRY(3, false, false, false, 0, 11, 11, ids_, &rtrans);
-    VERIFY_ENTRY(4, false, false, false, 0, 11, 11, ids_, &rtrans);
-  }
-}
-
-TEST_F(SyncerTest, EncryptionAwareConflicts) {
-  KeyParams key_params = {"localhost", "dummy", "foobar"};
-  browser_sync::Cryptographer other_cryptographer(&encryptor_);
-  other_cryptographer.AddKey(key_params);
-  sync_pb::EntitySpecifics bookmark, encrypted_bookmark, modified_bookmark;
-  bookmark.mutable_bookmark()->set_title("title");
-  other_cryptographer.Encrypt(bookmark,
-                              encrypted_bookmark.mutable_encrypted());
-  AddDefaultFieldValue(syncable::BOOKMARKS, &encrypted_bookmark);
-  modified_bookmark.mutable_bookmark()->set_title("title2");
-  other_cryptographer.Encrypt(modified_bookmark,
-                              modified_bookmark.mutable_encrypted());
-  sync_pb::EntitySpecifics pref, encrypted_pref, modified_pref;
-  pref.mutable_preference()->set_name("name");
-  AddDefaultFieldValue(syncable::PREFERENCES, &encrypted_pref);
-  other_cryptographer.Encrypt(pref,
-                              encrypted_pref.mutable_encrypted());
-  modified_pref.mutable_preference()->set_name("name2");
-  other_cryptographer.Encrypt(modified_pref,
-                              modified_pref.mutable_encrypted());
-  {
-    // Mark bookmarks and preferences as encrypted and set the cryptographer to
-    // have pending keys.
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    sync_pb::EntitySpecifics specifics;
-    sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
-    other_cryptographer.GetKeys(nigori->mutable_encrypted());
-    nigori->set_encrypt_bookmarks(true);
-    nigori->set_encrypt_preferences(true);
-    cryptographer(&wtrans)->Update(*nigori);
-    EXPECT_TRUE(cryptographer(&wtrans)->has_pending_keys());
-  }
-
-  mock_server_->AddUpdateSpecifics(1, 0, "A", 10, 10, true, 0, bookmark);
-  mock_server_->AddUpdateSpecifics(2, 1, "B", 10, 10, false, 2, bookmark);
-  mock_server_->AddUpdateSpecifics(3, 1, "C", 10, 10, false, 1, bookmark);
-  mock_server_->AddUpdateSpecifics(4, 0, "D", 10, 10, false, 0, pref);
-  SyncShareAsDelegate();
-  {
-    EXPECT_EQ(0U, session_->status_controller().unsynced_handles().size());
-    // Initial state. Everything is normal.
-    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);
-  }
-
-  // Server side encryption will not be applied due to undecryptable data.
-  // At this point, BASE_SERVER_SPECIFICS should be filled for all four items.
-  mock_server_->AddUpdateSpecifics(1, 0, kEncryptedString, 20, 20, true, 0,
-                                   encrypted_bookmark);
-  mock_server_->AddUpdateSpecifics(2, 1, kEncryptedString, 20, 20, false, 2,
-                                   encrypted_bookmark);
-  mock_server_->AddUpdateSpecifics(3, 1, kEncryptedString, 20, 20, false, 1,
-                                   encrypted_bookmark);
-  mock_server_->AddUpdateSpecifics(4, 0, kEncryptedString, 20, 20, false, 0,
-                                   encrypted_pref);
-  SyncShareAsDelegate();
-  {
-    EXPECT_EQ(0U, session_->status_controller().unsynced_handles().size());
-    // All should be unapplied due to being undecryptable and have a valid
-    // BASE_SERVER_SPECIFICS.
-    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);
-  mock_server_->AddUpdateSpecifics(2, 1, kEncryptedString, 30, 30, false, 2,
-                                   encrypted_bookmark);
-  // Item 3 doesn't change.
-  mock_server_->AddUpdateSpecifics(4, 0, kEncryptedString, 30, 30, false, 0,
-                                   encrypted_pref);
-  SyncShareAsDelegate();
-  {
-    EXPECT_EQ(0U, session_->status_controller().unsynced_handles().size());
-    // Items 1, 2, and 4 should have newer server versions, 3 remains the same.
-    // All should remain unapplied due to be undecryptable.
-    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);
-  // Reordered to after item 2.
-  mock_server_->AddUpdateSpecifics(3, 1, kEncryptedString, 30, 30, false, 3,
-                                   encrypted_bookmark);
-  SyncShareAsDelegate();
-  {
-    EXPECT_EQ(0U, session_->status_controller().unsynced_handles().size());
-    // Items 2 and 4 should be the only ones with BASE_SERVER_SPECIFICS set.
-    // Items 1 is now unencrypted, so should have applied normally.
-    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);
-  }
-
-  // Make local changes, which should remain unsynced for items 2, 3, 4.
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(A.good());
-    A.Put(SPECIFICS, modified_bookmark);
-    A.Put(NON_UNIQUE_NAME, kEncryptedString);
-    A.Put(IS_UNSYNCED, true);
-    MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(B.good());
-    B.Put(SPECIFICS, modified_bookmark);
-    B.Put(NON_UNIQUE_NAME, kEncryptedString);
-    B.Put(IS_UNSYNCED, true);
-    MutableEntry C(&wtrans, GET_BY_ID, ids_.FromNumber(3));
-    ASSERT_TRUE(C.good());
-    C.Put(SPECIFICS, modified_bookmark);
-    C.Put(NON_UNIQUE_NAME, kEncryptedString);
-    C.Put(IS_UNSYNCED, true);
-    MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
-    ASSERT_TRUE(D.good());
-    D.Put(SPECIFICS, modified_pref);
-    D.Put(NON_UNIQUE_NAME, kEncryptedString);
-    D.Put(IS_UNSYNCED, true);
-  }
-  SyncShareAsDelegate();
-  {
-    EXPECT_EQ(0U, session_->status_controller().unsynced_handles().size());
-    // Item 1 remains unsynced due to there being pending keys.
-    // Items 2, 3, 4 should remain unsynced since they were not up to date.
-    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);
-  }
-
-  {
-    ReadTransaction rtrans(FROM_HERE, directory());
-    // Resolve the pending keys.
-    cryptographer(&rtrans)->DecryptPendingKeys(key_params);
-  }
-  // First cycle resolves conflicts, second cycle commits changes.
-  SyncShareAsDelegate();
-  EXPECT_EQ(2, session_->status_controller().syncer_status().
-      num_server_overwrites);
-  EXPECT_EQ(1, session_->status_controller().syncer_status().
-      num_local_overwrites);
-  // We attempted to commit item 1.
-  EXPECT_EQ(1U, session_->status_controller().unsynced_handles().size());
-  EXPECT_TRUE(session_->status_controller().did_commit_items());
-  SyncShareAsDelegate();
-  {
-    // 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.
-    // We attempted to commit two handles.
-    EXPECT_EQ(0, session_->status_controller().syncer_status().
-        num_server_overwrites);
-    EXPECT_EQ(0, session_->status_controller().syncer_status().
-        num_local_overwrites);
-    EXPECT_EQ(2U, session_->status_controller().unsynced_handles().size());
-    EXPECT_TRUE(session_->status_controller().did_commit_items());
-    ReadTransaction rtrans(FROM_HERE, directory());
-    VERIFY_ENTRY(1, false, false, false, 0, 41, 41, ids_, &rtrans);
-    VERIFY_ENTRY(2, false, false, false, 1, 31, 31, ids_, &rtrans);
-    VERIFY_ENTRY(3, false, false, false, 1, 30, 30, ids_, &rtrans);
-    VERIFY_ENTRY(4, false, false, false, 0, 31, 31, ids_, &rtrans);
-  }
-}
-
-#undef VERIFY_ENTRY
-
-TEST_F(SyncerTest, NigoriConflicts) {
-  KeyParams local_key_params = {"localhost", "dummy", "blargle"};
-  KeyParams other_key_params = {"localhost", "dummy", "foobar"};
-  browser_sync::Cryptographer other_cryptographer(&encryptor_);
-  other_cryptographer.AddKey(other_key_params);
-  syncable::ModelTypeSet encrypted_types(syncable::PASSWORDS, syncable::NIGORI);
-  sync_pb::EntitySpecifics initial_nigori_specifics;
-  initial_nigori_specifics.mutable_nigori();
-  mock_server_->SetNigori(1, 10, 10, initial_nigori_specifics);
-
-  // Data for testing encryption/decryption.
-  sync_pb::EntitySpecifics other_encrypted_specifics;
-  other_encrypted_specifics.mutable_bookmark()->set_title("title");
-  other_cryptographer.Encrypt(
-      other_encrypted_specifics,
-      other_encrypted_specifics.mutable_encrypted());
-  sync_pb::EntitySpecifics our_encrypted_specifics;
-  our_encrypted_specifics.mutable_bookmark()->set_title("title2");
-
-  // Receive the initial nigori node.
-  SyncShareAsDelegate();
-  encrypted_types = syncable::ModelTypeSet::All();
-  {
-    // Local changes with different passphrase, different types, and sync_tabs.
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    sync_pb::EntitySpecifics specifics;
-    sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
-    cryptographer(&wtrans)->AddKey(local_key_params);
-    cryptographer(&wtrans)->Encrypt(
-        our_encrypted_specifics,
-        our_encrypted_specifics.mutable_encrypted());
-    cryptographer(&wtrans)->GetKeys(
-        nigori->mutable_encrypted());
-    cryptographer(&wtrans)->UpdateNigoriFromEncryptedTypes(nigori);
-    nigori->set_sync_tabs(true);
-    cryptographer(&wtrans)->set_encrypt_everything();
-    MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
-                              syncable::ModelTypeToRootTag(syncable::NIGORI));
-    ASSERT_TRUE(nigori_entry.good());
-    nigori_entry.Put(SPECIFICS, specifics);
-    nigori_entry.Put(IS_UNSYNCED, true);
-    EXPECT_FALSE(cryptographer(&wtrans)->has_pending_keys());
-    EXPECT_TRUE(encrypted_types.Equals(
-            cryptographer(&wtrans)->GetEncryptedTypes()));
-  }
-  {
-    sync_pb::EntitySpecifics specifics;
-    sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
-    other_cryptographer.GetKeys(nigori->mutable_encrypted());
-    nigori->set_encrypt_bookmarks(true);
-    nigori->set_encrypt_preferences(true);
-    nigori->set_encrypt_everything(false);
-    mock_server_->SetNigori(1, 20, 20, specifics);
-  }
-
-  // Will result in downloading the server nigori, which puts the local nigori
-  // in a state of conflict. This is resolved by merging the local and server
-  // data (with priority given to the server's encryption keys if they are
-  // undecryptable), which we then commit. The cryptographer should have pending
-  // keys and merge the set of encrypted types.
-  SyncShareAsDelegate();  // Resolve conflict in this cycle.
-  SyncShareAsDelegate();  // Commit local change in this cycle.
-  {
-    // Ensure the nigori data merged (encrypted types, sync_tabs).
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
-                              syncable::ModelTypeToRootTag(syncable::NIGORI));
-    ASSERT_TRUE(nigori_entry.good());
-    EXPECT_FALSE(nigori_entry.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(nigori_entry.Get(IS_UNSYNCED));
-    sync_pb::EntitySpecifics specifics = nigori_entry.Get(SPECIFICS);
-    EXPECT_TRUE(cryptographer(&wtrans)->has_pending_keys());
-    EXPECT_TRUE(encrypted_types.Equals(
-            cryptographer(&wtrans)->GetEncryptedTypes()));
-    EXPECT_TRUE(cryptographer(&wtrans)->encrypt_everything());
-    EXPECT_TRUE(specifics.nigori().sync_tabs());
-    // Supply the pending keys. Afterwards, we should be able to decrypt both
-    // our own encrypted data and data encrypted by the other cryptographer,
-    // but the key provided by the other cryptographer should be the default.
-    EXPECT_TRUE(cryptographer(&wtrans)->DecryptPendingKeys(other_key_params));
-    EXPECT_FALSE(cryptographer(&wtrans)->has_pending_keys());
-    sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
-    cryptographer(&wtrans)->GetKeys(nigori->mutable_encrypted());
-    cryptographer(&wtrans)->UpdateNigoriFromEncryptedTypes(nigori);
-    // Normally this would be written as part of SetPassphrase, but we do it
-    // manually for the test.
-    nigori_entry.Put(SPECIFICS, specifics);
-    nigori_entry.Put(IS_UNSYNCED, true);
-  }
-
-  SyncShareAsDelegate();
-  {
-    // Ensure everything is committed and stable now. The cryptographer
-    // should be able to decrypt both sets of keys, sync_tabs should be true,
-    // and the encrypted types should have been unioned.
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry nigori_entry(&wtrans, GET_BY_SERVER_TAG,
-                              syncable::ModelTypeToRootTag(syncable::NIGORI));
-    ASSERT_TRUE(nigori_entry.good());
-    EXPECT_FALSE(nigori_entry.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(nigori_entry.Get(IS_UNSYNCED));
-    EXPECT_TRUE(cryptographer(&wtrans)->CanDecrypt(
-        our_encrypted_specifics.encrypted()));
-    EXPECT_FALSE(cryptographer(&wtrans)->
-        CanDecryptUsingDefaultKey(our_encrypted_specifics.encrypted()));
-    EXPECT_TRUE(cryptographer(&wtrans)->CanDecrypt(
-        other_encrypted_specifics.encrypted()));
-    EXPECT_TRUE(cryptographer(&wtrans)->
-        CanDecryptUsingDefaultKey(other_encrypted_specifics.encrypted()));
-    EXPECT_TRUE(nigori_entry.Get(SPECIFICS).nigori().sync_tabs());
-  }
-}
-
-TEST_F(SyncerTest, TestGetUnsyncedAndSimpleCommit) {
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(),
-                        "Pete");
-    ASSERT_TRUE(parent.good());
-    parent.Put(syncable::IS_UNSYNCED, true);
-    parent.Put(syncable::IS_DIR, true);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    parent.Put(syncable::BASE_VERSION, 1);
-    parent.Put(syncable::ID, parent_id_);
-    MutableEntry child(&wtrans, syncable::CREATE, parent_id_, "Pete");
-    ASSERT_TRUE(child.good());
-    child.Put(syncable::ID, child_id_);
-    child.Put(syncable::BASE_VERSION, 1);
-    WriteTestDataToEntry(&wtrans, &child);
-  }
-
-  const StatusController& status = session_->status_controller();
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_EQ(2u, status.unsynced_handles().size());
-  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]);
-  {
-    ReadTransaction rt(FROM_HERE, directory());
-    Entry entry(&rt, syncable::GET_BY_ID, child_id_);
-    ASSERT_TRUE(entry.good());
-    VerifyTestDataInEntry(&rt, &entry);
-  }
-}
-
-TEST_F(SyncerTest, TestPurgeWhileUnsynced) {
-  // Similar to above, but throw a purge operation into the mix. Bug 49278.
-  syncable::Id pref_node_id = TestIdFactory::MakeServer("Tim");
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(), "Pete");
-    ASSERT_TRUE(parent.good());
-    parent.Put(syncable::IS_UNSYNCED, true);
-    parent.Put(syncable::IS_DIR, true);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    parent.Put(syncable::BASE_VERSION, 1);
-    parent.Put(syncable::ID, parent_id_);
-    MutableEntry child(&wtrans, syncable::CREATE, parent_id_, "Pete");
-    ASSERT_TRUE(child.good());
-    child.Put(syncable::ID, child_id_);
-    child.Put(syncable::BASE_VERSION, 1);
-    WriteTestDataToEntry(&wtrans, &child);
-
-    MutableEntry parent2(&wtrans, syncable::CREATE, wtrans.root_id(), "Tim");
-    ASSERT_TRUE(parent2.good());
-    parent2.Put(syncable::IS_UNSYNCED, true);
-    parent2.Put(syncable::IS_DIR, true);
-    parent2.Put(syncable::SPECIFICS, DefaultPreferencesSpecifics());
-    parent2.Put(syncable::BASE_VERSION, 1);
-    parent2.Put(syncable::ID, pref_node_id);
-  }
-
-  directory()->PurgeEntriesWithTypeIn(
-      syncable::ModelTypeSet(syncable::PREFERENCES));
-
-  const StatusController& status = session_->status_controller();
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_EQ(2U, status.unsynced_handles().size());
-  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]);
-  {
-    ReadTransaction rt(FROM_HERE, directory());
-    Entry entry(&rt, syncable::GET_BY_ID, child_id_);
-    ASSERT_TRUE(entry.good());
-    VerifyTestDataInEntry(&rt, &entry);
-  }
-  directory()->SaveChanges();
-  {
-    ReadTransaction rt(FROM_HERE, directory());
-    Entry entry(&rt, syncable::GET_BY_ID, pref_node_id);
-    ASSERT_FALSE(entry.good());
-  }
-}
-
-TEST_F(SyncerTest, TestPurgeWhileUnapplied) {
-  // Similar to above, but for unapplied items. Bug 49278.
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(), "Pete");
-    ASSERT_TRUE(parent.good());
-    parent.Put(syncable::IS_UNAPPLIED_UPDATE, true);
-    parent.Put(syncable::IS_DIR, true);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    parent.Put(syncable::BASE_VERSION, 1);
-    parent.Put(syncable::ID, parent_id_);
-  }
-
-  directory()->PurgeEntriesWithTypeIn(
-      syncable::ModelTypeSet(syncable::BOOKMARKS));
-
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  directory()->SaveChanges();
-  {
-    ReadTransaction rt(FROM_HERE, directory());
-    Entry entry(&rt, syncable::GET_BY_ID, parent_id_);
-    ASSERT_FALSE(entry.good());
-  }
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingTwoItemsTall) {
-  CommitOrderingTest items[] = {
-    {1, ids_.FromNumber(-1001), ids_.FromNumber(-1000)},
-    {0, ids_.FromNumber(-1000), ids_.FromNumber(0)},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingThreeItemsTall) {
-  CommitOrderingTest items[] = {
-    {1, ids_.FromNumber(-2001), ids_.FromNumber(-2000)},
-    {0, ids_.FromNumber(-2000), ids_.FromNumber(0)},
-    {2, ids_.FromNumber(-2002), ids_.FromNumber(-2001)},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingThreeItemsTallLimitedSize) {
-  context_->set_max_commit_batch_size(2);
-  CommitOrderingTest items[] = {
-    {1, ids_.FromNumber(-2001), ids_.FromNumber(-2000)},
-    {0, ids_.FromNumber(-2000), ids_.FromNumber(0)},
-    {2, ids_.FromNumber(-2002), ids_.FromNumber(-2001)},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingSingleDeletedItem) {
-  CommitOrderingTest items[] = {
-    {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED}},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingSingleUncommittedDeletedItem) {
-  CommitOrderingTest items[] = {
-    {-1, ids_.FromNumber(-1000), ids_.FromNumber(0), {DELETED}},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingSingleDeletedItemWithUnroll) {
-  CommitOrderingTest items[] = {
-    {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED}},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest,
-       TestCommitListOrderingSingleLongDeletedItemWithUnroll) {
-  CommitOrderingTest items[] = {
-    {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingTwoLongDeletedItemWithUnroll) {
-  CommitOrderingTest items[] = {
-    {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    {-1, ids_.FromNumber(1001), ids_.FromNumber(1000), {DELETED, OLD_MTIME}},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest, TestCommitListOrdering3LongDeletedItemsWithSizeLimit) {
-  context_->set_max_commit_batch_size(2);
-  CommitOrderingTest items[] = {
-    {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    {1, ids_.FromNumber(1001), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    {2, ids_.FromNumber(1002), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingTwoDeletedItemsWithUnroll) {
-  CommitOrderingTest items[] = {
-    {0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED}},
-    {-1, ids_.FromNumber(1001), ids_.FromNumber(1000), {DELETED}},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingComplexDeletionScenario) {
-  CommitOrderingTest items[] = {
-    { 0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    {-1, ids_.FromNumber(1001), ids_.FromNumber(0), {SYNCED}},
-    {1, ids_.FromNumber(1002), ids_.FromNumber(1001), {DELETED, OLD_MTIME}},
-    {-1, ids_.FromNumber(1003), ids_.FromNumber(1001), {SYNCED}},
-    {2, ids_.FromNumber(1004), ids_.FromNumber(1003), {DELETED}},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest,
-       TestCommitListOrderingComplexDeletionScenarioWith2RecentDeletes) {
-  CommitOrderingTest items[] = {
-    { 0, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    {-1, ids_.FromNumber(1001), ids_.FromNumber(0), {SYNCED}},
-    {1, ids_.FromNumber(1002), ids_.FromNumber(1001), {DELETED, OLD_MTIME}},
-    {-1, ids_.FromNumber(1003), ids_.FromNumber(1001), {SYNCED}},
-    {2, ids_.FromNumber(1004), ids_.FromNumber(1003), {DELETED}},
-    {3, ids_.FromNumber(1005), ids_.FromNumber(1003), {DELETED}},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingDeleteMovedItems) {
-  CommitOrderingTest items[] = {
-    {1, ids_.FromNumber(1000), ids_.FromNumber(0), {DELETED, OLD_MTIME}},
-    {0, ids_.FromNumber(1001), ids_.FromNumber(1000), {DELETED, OLD_MTIME,
-                                              MOVED_FROM_ROOT}},
-    CommitOrderingTest::LAST_COMMIT_ITEM,
-  };
-  RunCommitOrderingTest(items);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingWithNesting) {
-  const base::Time& now_minus_2h =
-      base::Time::Now() - base::TimeDelta::FromHours(2);
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    {
-      MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(),
-                          "Bob");
-      ASSERT_TRUE(parent.good());
-      parent.Put(syncable::IS_UNSYNCED, true);
-      parent.Put(syncable::IS_DIR, true);
-      parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-      parent.Put(syncable::ID, ids_.FromNumber(100));
-      parent.Put(syncable::BASE_VERSION, 1);
-      MutableEntry child(&wtrans, syncable::CREATE, ids_.FromNumber(100),
-                         "Bob");
-      ASSERT_TRUE(child.good());
-      child.Put(syncable::IS_UNSYNCED, true);
-      child.Put(syncable::IS_DIR, true);
-      child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-      child.Put(syncable::ID, ids_.FromNumber(101));
-      child.Put(syncable::BASE_VERSION, 1);
-      MutableEntry grandchild(&wtrans, syncable::CREATE, ids_.FromNumber(101),
-                              "Bob");
-      ASSERT_TRUE(grandchild.good());
-      grandchild.Put(syncable::ID, ids_.FromNumber(102));
-      grandchild.Put(syncable::IS_UNSYNCED, true);
-      grandchild.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-      grandchild.Put(syncable::BASE_VERSION, 1);
-    }
-    {
-      // Create three deleted items which deletions we expect to be sent to the
-      // server.
-      MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(),
-                          "Pete");
-      ASSERT_TRUE(parent.good());
-      parent.Put(syncable::IS_UNSYNCED, true);
-      parent.Put(syncable::IS_DIR, true);
-      parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-      parent.Put(syncable::IS_DEL, true);
-      parent.Put(syncable::ID, ids_.FromNumber(103));
-      parent.Put(syncable::BASE_VERSION, 1);
-      parent.Put(syncable::MTIME, now_minus_2h);
-      MutableEntry child(&wtrans, syncable::CREATE, ids_.FromNumber(103),
-                         "Pete");
-      ASSERT_TRUE(child.good());
-      child.Put(syncable::IS_UNSYNCED, true);
-      child.Put(syncable::IS_DIR, true);
-      child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-      child.Put(syncable::IS_DEL, true);
-      child.Put(syncable::ID, ids_.FromNumber(104));
-      child.Put(syncable::BASE_VERSION, 1);
-      child.Put(syncable::MTIME, now_minus_2h);
-      MutableEntry grandchild(&wtrans, syncable::CREATE, ids_.FromNumber(104),
-                              "Pete");
-      ASSERT_TRUE(grandchild.good());
-      grandchild.Put(syncable::IS_UNSYNCED, true);
-      grandchild.Put(syncable::ID, ids_.FromNumber(105));
-      grandchild.Put(syncable::IS_DEL, true);
-      grandchild.Put(syncable::IS_DIR, false);
-      grandchild.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-      grandchild.Put(syncable::BASE_VERSION, 1);
-      grandchild.Put(syncable::MTIME, now_minus_2h);
-    }
-  }
-
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_EQ(6u, session_->status_controller().unsynced_handles().size());
-  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());
-  EXPECT_TRUE(ids_.FromNumber(103) == commit_ids[3]);
-  EXPECT_TRUE(ids_.FromNumber(104) == commit_ids[4]);
-  EXPECT_TRUE(ids_.FromNumber(105) == commit_ids[5]);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingWithNewItems) {
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(), "1");
-    ASSERT_TRUE(parent.good());
-    parent.Put(syncable::IS_UNSYNCED, true);
-    parent.Put(syncable::IS_DIR, true);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    parent.Put(syncable::ID, parent_id_);
-    MutableEntry child(&wtrans, syncable::CREATE, wtrans.root_id(), "2");
-    ASSERT_TRUE(child.good());
-    child.Put(syncable::IS_UNSYNCED, true);
-    child.Put(syncable::IS_DIR, true);
-    child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    child.Put(syncable::ID, child_id_);
-    parent.Put(syncable::BASE_VERSION, 1);
-    child.Put(syncable::BASE_VERSION, 1);
-  }
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans, syncable::CREATE, parent_id_, "A");
-    ASSERT_TRUE(parent.good());
-    parent.Put(syncable::IS_UNSYNCED, true);
-    parent.Put(syncable::IS_DIR, true);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    parent.Put(syncable::ID, ids_.FromNumber(102));
-    MutableEntry child(&wtrans, syncable::CREATE, parent_id_, "B");
-    ASSERT_TRUE(child.good());
-    child.Put(syncable::IS_UNSYNCED, true);
-    child.Put(syncable::IS_DIR, true);
-    child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    child.Put(syncable::ID, ids_.FromNumber(-103));
-    parent.Put(syncable::BASE_VERSION, 1);
-  }
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans, syncable::CREATE, child_id_, "A");
-    ASSERT_TRUE(parent.good());
-    parent.Put(syncable::IS_UNSYNCED, true);
-    parent.Put(syncable::IS_DIR, true);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    parent.Put(syncable::ID, ids_.FromNumber(-104));
-    MutableEntry child(&wtrans, syncable::CREATE, child_id_, "B");
-    ASSERT_TRUE(child.good());
-    child.Put(syncable::IS_UNSYNCED, true);
-    child.Put(syncable::IS_DIR, true);
-    child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    child.Put(syncable::ID, ids_.FromNumber(105));
-    child.Put(syncable::BASE_VERSION, 1);
-  }
-
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_EQ(6u, session_->status_controller().unsynced_handles().size());
-  ASSERT_EQ(6u, 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]);
-  EXPECT_TRUE(ids_.FromNumber(102) == mock_server_->committed_ids()[2]);
-  EXPECT_TRUE(ids_.FromNumber(-103) == mock_server_->committed_ids()[3]);
-  EXPECT_TRUE(ids_.FromNumber(-104) == mock_server_->committed_ids()[4]);
-  EXPECT_TRUE(ids_.FromNumber(105) == mock_server_->committed_ids()[5]);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingCounterexample) {
-  syncable::Id child2_id = ids_.NewServerId();
-
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(), "P");
-    ASSERT_TRUE(parent.good());
-    parent.Put(syncable::IS_UNSYNCED, true);
-    parent.Put(syncable::IS_DIR, true);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    parent.Put(syncable::ID, parent_id_);
-    MutableEntry child1(&wtrans, syncable::CREATE, parent_id_, "1");
-    ASSERT_TRUE(child1.good());
-    child1.Put(syncable::IS_UNSYNCED, true);
-    child1.Put(syncable::ID, child_id_);
-    child1.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    MutableEntry child2(&wtrans, syncable::CREATE, parent_id_, "2");
-    ASSERT_TRUE(child2.good());
-    child2.Put(syncable::IS_UNSYNCED, true);
-    child2.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    child2.Put(syncable::ID, child2_id);
-
-    parent.Put(syncable::BASE_VERSION, 1);
-    child1.Put(syncable::BASE_VERSION, 1);
-    child2.Put(syncable::BASE_VERSION, 1);
-  }
-
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_EQ(3u, session_->status_controller().unsynced_handles().size());
-  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(child_id_ == mock_server_->committed_ids()[1]);
-  EXPECT_TRUE(child2_id == mock_server_->committed_ids()[2]);
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingAndNewParent) {
-  string parent1_name = "1";
-  string parent2_name = "A";
-  string child_name = "B";
-
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(),
-                        parent1_name);
-    ASSERT_TRUE(parent.good());
-    parent.Put(syncable::IS_UNSYNCED, true);
-    parent.Put(syncable::IS_DIR, true);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    parent.Put(syncable::ID, parent_id_);
-    parent.Put(syncable::BASE_VERSION, 1);
-  }
-
-  syncable::Id parent2_id = ids_.NewLocalId();
-  syncable::Id child_id = ids_.NewServerId();
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent2(&wtrans, syncable::CREATE, parent_id_, parent2_name);
-    ASSERT_TRUE(parent2.good());
-    parent2.Put(syncable::IS_UNSYNCED, true);
-    parent2.Put(syncable::IS_DIR, true);
-    parent2.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    parent2.Put(syncable::ID, parent2_id);
-
-    MutableEntry child(&wtrans, syncable::CREATE, parent2_id, child_name);
-    ASSERT_TRUE(child.good());
-    child.Put(syncable::IS_UNSYNCED, true);
-    child.Put(syncable::IS_DIR, true);
-    child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    child.Put(syncable::ID, child_id);
-    child.Put(syncable::BASE_VERSION, 1);
-  }
-
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_EQ(3u, session_->status_controller().unsynced_handles().size());
-  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]);
-  {
-    ReadTransaction rtrans(FROM_HERE, directory());
-    // Check that things committed correctly.
-    Entry entry_1(&rtrans, syncable::GET_BY_ID, parent_id_);
-    EXPECT_EQ(entry_1.Get(NON_UNIQUE_NAME), parent1_name);
-    // Check that parent2 is a subfolder of parent1.
-    EXPECT_EQ(1, CountEntriesWithName(&rtrans,
-                                      parent_id_,
-                                      parent2_name));
-
-    // Parent2 was a local ID and thus should have changed on commit!
-    Entry pre_commit_entry_parent2(&rtrans, syncable::GET_BY_ID, parent2_id);
-    ASSERT_FALSE(pre_commit_entry_parent2.good());
-
-    // Look up the new ID.
-    Id parent2_committed_id =
-        GetOnlyEntryWithName(&rtrans, parent_id_, parent2_name);
-    EXPECT_TRUE(parent2_committed_id.ServerKnows());
-
-    Entry child(&rtrans, syncable::GET_BY_ID, child_id);
-    EXPECT_EQ(parent2_committed_id, child.Get(syncable::PARENT_ID));
-  }
-}
-
-TEST_F(SyncerTest, TestCommitListOrderingAndNewParentAndChild) {
-  string parent_name = "1";
-  string parent2_name = "A";
-  string child_name = "B";
-
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans,
-                        syncable::CREATE,
-                        wtrans.root_id(),
-                        parent_name);
-    ASSERT_TRUE(parent.good());
-    parent.Put(syncable::IS_UNSYNCED, true);
-    parent.Put(syncable::IS_DIR, true);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    parent.Put(syncable::ID, parent_id_);
-    parent.Put(syncable::BASE_VERSION, 1);
-  }
-
-  int64 meta_handle_b;
-  const Id parent2_local_id = ids_.NewLocalId();
-  const Id child_local_id = ids_.NewLocalId();
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent2(&wtrans, syncable::CREATE, parent_id_, parent2_name);
-    ASSERT_TRUE(parent2.good());
-    parent2.Put(syncable::IS_UNSYNCED, true);
-    parent2.Put(syncable::IS_DIR, true);
-    parent2.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-
-    parent2.Put(syncable::ID, parent2_local_id);
-    MutableEntry child(&wtrans, syncable::CREATE, parent2_local_id, child_name);
-    ASSERT_TRUE(child.good());
-    child.Put(syncable::IS_UNSYNCED, true);
-    child.Put(syncable::IS_DIR, true);
-    child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    child.Put(syncable::ID, child_local_id);
-    meta_handle_b = child.Get(syncable::META_HANDLE);
-  }
-
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  EXPECT_EQ(3u, session_->status_controller().unsynced_handles().size());
-  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]);
-  {
-    ReadTransaction rtrans(FROM_HERE, directory());
-
-    Entry parent(&rtrans, syncable::GET_BY_ID,
-                 GetOnlyEntryWithName(&rtrans, rtrans.root_id(), parent_name));
-    ASSERT_TRUE(parent.good());
-    EXPECT_TRUE(parent.Get(syncable::ID).ServerKnows());
-
-    Entry parent2(&rtrans, syncable::GET_BY_ID,
-                  GetOnlyEntryWithName(&rtrans, parent.Get(ID), parent2_name));
-    ASSERT_TRUE(parent2.good());
-    EXPECT_TRUE(parent2.Get(syncable::ID).ServerKnows());
-
-    // Id changed on commit, so this should fail.
-    Entry local_parent2_id_entry(&rtrans,
-                                 syncable::GET_BY_ID,
-                                 parent2_local_id);
-    ASSERT_FALSE(local_parent2_id_entry.good());
-
-    Entry entry_b(&rtrans, syncable::GET_BY_HANDLE, meta_handle_b);
-    EXPECT_TRUE(entry_b.Get(syncable::ID).ServerKnows());
-    EXPECT_TRUE(parent2.Get(syncable::ID) == entry_b.Get(syncable::PARENT_ID));
-  }
-}
-
-TEST_F(SyncerTest, UpdateWithZeroLengthName) {
-  // One illegal update
-  mock_server_->AddUpdateDirectory(1, 0, "", 1, 10);
-  // And one legal one that we're going to delete.
-  mock_server_->AddUpdateDirectory(2, 0, "FOO", 1, 10);
-  SyncShareAsDelegate();
-  // Delete the legal one. The new update has a null name.
-  mock_server_->AddUpdateDirectory(2, 0, "", 2, 20);
-  mock_server_->SetLastUpdateDeleted();
-  SyncShareAsDelegate();
-}
-
-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);
-
-  SyncShareAsDelegate();
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    Entry entry(&trans, GET_BY_ID,
-               syncable::Id::CreateFromServerId("some_id"));
-    ASSERT_TRUE(entry.good());
-    EXPECT_TRUE(entry.Get(IS_DIR));
-    EXPECT_TRUE(entry.Get(SERVER_VERSION) == version);
-    EXPECT_TRUE(entry.Get(BASE_VERSION) == version);
-    EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(entry.Get(IS_UNSYNCED));
-    EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
-    EXPECT_FALSE(entry.Get(IS_DEL));
-  }
-}
-
-TEST_F(SyncerTest, IllegalAndLegalUpdates) {
-  Id root = TestIdFactory::root();
-  // Should apply just fine.
-  mock_server_->AddUpdateDirectory(1, 0, "in_root", 10, 10);
-
-  // Same name. But this SHOULD work.
-  mock_server_->AddUpdateDirectory(2, 0, "in_root", 10, 10);
-
-  // 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);
-
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  StatusController* status = session_->mutable_status_controller();
-
-  // Id 3 should be in conflict now.
-  EXPECT_EQ(1, status->TotalNumConflictingItems());
-  {
-    sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-    ASSERT_TRUE(status->conflict_progress());
-    EXPECT_EQ(1, status->conflict_progress()->HierarchyConflictingItemsSize());
-  }
-
-  // These entries will be used in the second set of updates.
-  mock_server_->AddUpdateDirectory(4, 0, "newer_version", 20, 10);
-  mock_server_->AddUpdateDirectory(5, 0, "circular1", 10, 10);
-  mock_server_->AddUpdateDirectory(6, 5, "circular2", 10, 10);
-  mock_server_->AddUpdateDirectory(9, 3, "bad_parent_child", 10, 10);
-  mock_server_->AddUpdateDirectory(100, 9, "bad_parent_child2", 10, 10);
-  mock_server_->AddUpdateDirectory(10, 0, "dir_to_bookmark", 10, 10);
-
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  // 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, status->TotalNumConflictingItems());
-  {
-    sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-    ASSERT_TRUE(status->conflict_progress());
-    EXPECT_EQ(3, status->conflict_progress()->HierarchyConflictingItemsSize());
-  }
-
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    // Even though it has the same name, it should work.
-    Entry name_clash(&trans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(name_clash.good());
-    EXPECT_FALSE(name_clash.Get(IS_UNAPPLIED_UPDATE))
-        << "Duplicate name SHOULD be OK.";
-
-    Entry bad_parent(&trans, GET_BY_ID, ids_.FromNumber(3));
-    ASSERT_TRUE(bad_parent.good());
-    EXPECT_TRUE(bad_parent.Get(IS_UNAPPLIED_UPDATE))
-        << "child of unknown parent should be in conflict";
-
-    Entry bad_parent_child(&trans, GET_BY_ID, ids_.FromNumber(9));
-    ASSERT_TRUE(bad_parent_child.good());
-    EXPECT_TRUE(bad_parent_child.Get(IS_UNAPPLIED_UPDATE))
-        << "grandchild of unknown parent should be in conflict";
-
-    Entry bad_parent_child2(&trans, GET_BY_ID, ids_.FromNumber(100));
-    ASSERT_TRUE(bad_parent_child2.good());
-    EXPECT_TRUE(bad_parent_child2.Get(IS_UNAPPLIED_UPDATE))
-        << "great-grandchild of unknown parent should be in conflict";
-  }
-
-  // Updating 1 should not affect item 2 of the same name.
-  mock_server_->AddUpdateDirectory(1, 0, "new_name", 20, 20);
-
-  // Moving 5 under 6 will create a cycle: a conflict.
-  mock_server_->AddUpdateDirectory(5, 6, "circular3", 20, 20);
-
-  // Flip the is_dir bit: should fail verify & be dropped.
-  mock_server_->AddUpdateBookmark(10, 0, "dir_to_bookmark", 20, 20);
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-
-  // Version number older than last known: should fail verify & be dropped.
-  mock_server_->AddUpdateDirectory(4, 0, "old_version", 10, 10);
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  {
-    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.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_EQ(10u, still_a_dir.Get(BASE_VERSION));
-    EXPECT_EQ(10u, still_a_dir.Get(SERVER_VERSION));
-    EXPECT_TRUE(still_a_dir.Get(IS_DIR));
-
-    Entry rename(&trans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(rename.good());
-    EXPECT_EQ(root, rename.Get(PARENT_ID));
-    EXPECT_EQ("new_name", rename.Get(NON_UNIQUE_NAME));
-    EXPECT_FALSE(rename.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(ids_.FromNumber(1) == rename.Get(ID));
-    EXPECT_EQ(20u, rename.Get(BASE_VERSION));
-
-    Entry name_clash(&trans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(name_clash.good());
-    EXPECT_EQ(root, name_clash.Get(PARENT_ID));
-    EXPECT_TRUE(ids_.FromNumber(2) == name_clash.Get(ID));
-    EXPECT_EQ(10u, name_clash.Get(BASE_VERSION));
-    EXPECT_EQ("in_root", name_clash.Get(NON_UNIQUE_NAME));
-
-    Entry ignored_old_version(&trans, GET_BY_ID, ids_.FromNumber(4));
-    ASSERT_TRUE(ignored_old_version.good());
-    EXPECT_TRUE(
-        ignored_old_version.Get(NON_UNIQUE_NAME) == "newer_version");
-    EXPECT_FALSE(ignored_old_version.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_EQ(20u, ignored_old_version.Get(BASE_VERSION));
-
-    Entry circular_parent_issue(&trans, GET_BY_ID, ids_.FromNumber(5));
-    ASSERT_TRUE(circular_parent_issue.good());
-    EXPECT_TRUE(circular_parent_issue.Get(IS_UNAPPLIED_UPDATE))
-        << "circular move should be in conflict";
-    EXPECT_TRUE(circular_parent_issue.Get(PARENT_ID) == root_id_);
-    EXPECT_TRUE(circular_parent_issue.Get(SERVER_PARENT_ID) ==
-                ids_.FromNumber(6));
-    EXPECT_EQ(10u, circular_parent_issue.Get(BASE_VERSION));
-
-    Entry circular_parent_target(&trans, GET_BY_ID, ids_.FromNumber(6));
-    ASSERT_TRUE(circular_parent_target.good());
-    EXPECT_FALSE(circular_parent_target.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(circular_parent_issue.Get(ID) ==
-        circular_parent_target.Get(PARENT_ID));
-    EXPECT_EQ(10u, circular_parent_target.Get(BASE_VERSION));
-  }
-
-  EXPECT_FALSE(saw_syncer_event_);
-  EXPECT_EQ(4, status->TotalNumConflictingItems());
-  {
-    sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
-    ASSERT_TRUE(status->conflict_progress());
-    EXPECT_EQ(4, status->conflict_progress()->HierarchyConflictingItemsSize());
-  }
-}
-
-TEST_F(SyncerTest, CommitTimeRename) {
-  int64 metahandle_folder;
-  int64 metahandle_new_entry;
-
-  // Create a folder and an entry.
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&trans, CREATE, root_id_, "Folder");
-    ASSERT_TRUE(parent.good());
-    parent.Put(IS_DIR, true);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    parent.Put(IS_UNSYNCED, true);
-    metahandle_folder = parent.Get(META_HANDLE);
-
-    MutableEntry entry(&trans, CREATE, parent.Get(ID), "new_entry");
-    ASSERT_TRUE(entry.good());
-    metahandle_new_entry = entry.Get(META_HANDLE);
-    WriteTestDataToEntry(&trans, &entry);
-  }
-
-  // Mix in a directory creation too for later.
-  mock_server_->AddUpdateDirectory(2, 0, "dir_in_root", 10, 10);
-  mock_server_->SetCommitTimeRename("renamed_");
-  SyncShareAsDelegate();
-
-  // Verify it was correctly renamed.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry_folder(&trans, GET_BY_HANDLE, metahandle_folder);
-    ASSERT_TRUE(entry_folder.good());
-    EXPECT_EQ("renamed_Folder", entry_folder.Get(NON_UNIQUE_NAME));
-
-    Entry entry_new(&trans, GET_BY_HANDLE, metahandle_new_entry);
-    ASSERT_TRUE(entry_new.good());
-    EXPECT_EQ(entry_folder.Get(ID), entry_new.Get(PARENT_ID));
-    EXPECT_EQ("renamed_new_entry", entry_new.Get(NON_UNIQUE_NAME));
-
-    // And that the unrelated directory creation worked without a rename.
-    Entry new_dir(&trans, GET_BY_ID, ids_.FromNumber(2));
-    EXPECT_TRUE(new_dir.good());
-    EXPECT_EQ("dir_in_root", new_dir.Get(NON_UNIQUE_NAME));
-  }
-}
-
-
-TEST_F(SyncerTest, CommitTimeRenameI18N) {
-  // This is utf-8 for the diacritized Internationalization.
-  const char* i18nString = "\xc3\x8e\xc3\xb1\x74\xc3\xa9\x72\xc3\xb1"
-      "\xc3\xa5\x74\xc3\xae\xc3\xb6\xc3\xb1\xc3\xa5\x6c\xc3\xae"
-      "\xc2\x9e\xc3\xa5\x74\xc3\xae\xc3\xb6\xc3\xb1";
-
-  int64 metahandle;
-  // Create a folder, expect a commit time rename.
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&trans, CREATE, root_id_, "Folder");
-    ASSERT_TRUE(parent.good());
-    parent.Put(IS_DIR, true);
-    parent.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    parent.Put(IS_UNSYNCED, true);
-    metahandle = parent.Get(META_HANDLE);
-  }
-
-  mock_server_->SetCommitTimeRename(i18nString);
-  SyncShareAsDelegate();
-
-  // Verify it was correctly renamed.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    string expected_folder_name(i18nString);
-    expected_folder_name.append("Folder");
-
-
-    Entry entry_folder(&trans, GET_BY_HANDLE, metahandle);
-    ASSERT_TRUE(entry_folder.good());
-    EXPECT_EQ(expected_folder_name, entry_folder.Get(NON_UNIQUE_NAME));
-  }
-}
-
-// A commit with a lost response produces an update that has to be reunited with
-// its parent.
-TEST_F(SyncerTest, CommitReuniteUpdateAdjustsChildren) {
-  // Create a folder in the root.
-  int64 metahandle_folder;
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, CREATE, trans.root_id(), "new_folder");
-    ASSERT_TRUE(entry.good());
-    entry.Put(IS_DIR, true);
-    entry.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    entry.Put(IS_UNSYNCED, true);
-    metahandle_folder = entry.Get(META_HANDLE);
-  }
-
-  // Verify it and pull the ID out of the folder.
-  syncable::Id folder_id;
-  int64 metahandle_entry;
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_HANDLE, metahandle_folder);
-    ASSERT_TRUE(entry.good());
-    folder_id = entry.Get(ID);
-    ASSERT_TRUE(!folder_id.ServerKnows());
-  }
-
-  // Create an entry in the newly created folder.
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, CREATE, folder_id, "new_entry");
-    ASSERT_TRUE(entry.good());
-    metahandle_entry = entry.Get(META_HANDLE);
-    WriteTestDataToEntry(&trans, &entry);
-  }
-
-  // Verify it and pull the ID out of the entry.
-  syncable::Id entry_id;
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, syncable::GET_BY_HANDLE, metahandle_entry);
-    ASSERT_TRUE(entry.good());
-    EXPECT_EQ(folder_id, entry.Get(PARENT_ID));
-    EXPECT_EQ("new_entry", entry.Get(NON_UNIQUE_NAME));
-    entry_id = entry.Get(ID);
-    EXPECT_TRUE(!entry_id.ServerKnows());
-    VerifyTestDataInEntry(&trans, &entry);
-  }
-
-  // Now, to emulate a commit response failure, we just don't commit it.
-  int64 new_version = 150;  // any larger value.
-  int64 timestamp = 20;  // arbitrary value.
-  syncable::Id new_folder_id =
-      syncable::Id::CreateFromServerId("folder_server_id");
-
-  // 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);
-  mock_server_->SetLastUpdateOriginatorFields(
-      directory()->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!
-  SyncShareAsDelegate();
-  {
-    // The folder's ID should have been updated.
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry folder(&trans, GET_BY_HANDLE, metahandle_folder);
-    ASSERT_TRUE(folder.good());
-    EXPECT_EQ("new_folder", folder.Get(NON_UNIQUE_NAME));
-    EXPECT_TRUE(new_version == folder.Get(BASE_VERSION));
-    EXPECT_TRUE(new_folder_id == folder.Get(ID));
-    EXPECT_TRUE(folder.Get(ID).ServerKnows());
-    EXPECT_EQ(trans.root_id(), folder.Get(PARENT_ID));
-
-    // Since it was updated, the old folder should not exist.
-    Entry old_dead_folder(&trans, GET_BY_ID, folder_id);
-    EXPECT_FALSE(old_dead_folder.good());
-
-    // The child's parent should have changed.
-    Entry entry(&trans, syncable::GET_BY_HANDLE, metahandle_entry);
-    ASSERT_TRUE(entry.good());
-    EXPECT_EQ("new_entry", entry.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(new_folder_id, entry.Get(PARENT_ID));
-    EXPECT_TRUE(!entry.Get(ID).ServerKnows());
-    VerifyTestDataInEntry(&trans, &entry);
-  }
-}
-
-// A commit with a lost response produces an update that has to be reunited with
-// its parent.
-TEST_F(SyncerTest, CommitReuniteUpdate) {
-  // Create an entry in the root.
-  int64 entry_metahandle;
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, CREATE, trans.root_id(), "new_entry");
-    ASSERT_TRUE(entry.good());
-    entry_metahandle = entry.Get(META_HANDLE);
-    WriteTestDataToEntry(&trans, &entry);
-  }
-
-  // Verify it and pull the ID out.
-  syncable::Id entry_id;
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-
-    Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
-    ASSERT_TRUE(entry.good());
-    entry_id = entry.Get(ID);
-    EXPECT_TRUE(!entry_id.ServerKnows());
-    VerifyTestDataInEntry(&trans, &entry);
-  }
-
-  // Now, to emulate a commit response failure, we just don't commit it.
-  int64 new_version = 150;  // any larger value.
-  int64 timestamp = 20;  // arbitrary value.
-  syncable::Id new_entry_id = syncable::Id::CreateFromServerId("server_id");
-
-  // Generate an update from the server with a relevant ID reassignment.
-  mock_server_->AddUpdateBookmark(new_entry_id, root_id_,
-      "new_entry", new_version, timestamp);
-  mock_server_->SetLastUpdateOriginatorFields(
-      directory()->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!
-  SyncShareAsDelegate();
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
-    ASSERT_TRUE(entry.good());
-    EXPECT_TRUE(new_version == entry.Get(BASE_VERSION));
-    EXPECT_TRUE(new_entry_id == entry.Get(ID));
-    EXPECT_EQ("new_entry", entry.Get(NON_UNIQUE_NAME));
-  }
-}
-
-// A commit with a lost response must work even if the local entry was deleted
-// before the update is applied. We should not duplicate the local entry in
-// this case, but just create another one alongside. We may wish to examine
-// this behavior in the future as it can create hanging uploads that never
-// finish, that must be cleaned up on the server side after some time.
-TEST_F(SyncerTest, CommitReuniteUpdateDoesNotChokeOnDeletedLocalEntry) {
-  // Create a entry in the root.
-  int64 entry_metahandle;
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, CREATE, trans.root_id(), "new_entry");
-    ASSERT_TRUE(entry.good());
-    entry_metahandle = entry.Get(META_HANDLE);
-    WriteTestDataToEntry(&trans, &entry);
-  }
-  // Verify it and pull the ID out.
-  syncable::Id entry_id;
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
-    ASSERT_TRUE(entry.good());
-    entry_id = entry.Get(ID);
-    EXPECT_TRUE(!entry_id.ServerKnows());
-    VerifyTestDataInEntry(&trans, &entry);
-  }
-
-  // Now, to emulate a commit response failure, we just don't commit it.
-  int64 new_version = 150;  // any larger value.
-  int64 timestamp = 20;  // arbitrary value.
-  syncable::Id new_entry_id = syncable::Id::CreateFromServerId("server_id");
-
-  // Generate an update from the server with a relevant ID reassignment.
-  mock_server_->AddUpdateBookmark(new_entry_id, root_id_,
-      "new_entry", new_version, timestamp);
-  mock_server_->SetLastUpdateOriginatorFields(
-      directory()->cache_guid(),
-      entry_id.GetServerId());
-
-  // We don't want it accidentally committed, just the update applied.
-  mock_server_->set_conflict_all_commits(true);
-
-  // Purposefully delete the entry now before the update application finishes.
-  {
-    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.Put(syncable::IS_DEL, true);
-  }
-
-  // Just don't CHECK fail in sync, have the update split.
-  SyncShareAsDelegate();
-  {
-    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.Get(IS_DEL));
-
-    Entry old_entry(&trans, GET_BY_ID, entry_id);
-    ASSERT_TRUE(old_entry.good());
-    EXPECT_TRUE(old_entry.Get(IS_DEL));
-  }
-}
-
-// TODO(chron): Add more unsanitized name tests.
-TEST_F(SyncerTest, ConflictMatchingEntryHandlesUnsanitizedNames) {
-  mock_server_->AddUpdateDirectory(1, 0, "A/A", 10, 10);
-  mock_server_->AddUpdateDirectory(2, 0, "B/B", 10, 10);
-  mock_server_->set_conflict_all_commits(true);
-  SyncShareAsDelegate();
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-
-    MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(A.good());
-    A.Put(IS_UNSYNCED, true);
-    A.Put(IS_UNAPPLIED_UPDATE, true);
-    A.Put(SERVER_VERSION, 20);
-
-    MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(B.good());
-    B.Put(IS_UNAPPLIED_UPDATE, true);
-    B.Put(SERVER_VERSION, 20);
-  }
-  LoopSyncShare();
-  saw_syncer_event_ = false;
-  mock_server_->set_conflict_all_commits(false);
-
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-
-    Entry A(&trans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(A.good());
-    EXPECT_TRUE(A.Get(IS_UNSYNCED) == false);
-    EXPECT_TRUE(A.Get(IS_UNAPPLIED_UPDATE) == false);
-    EXPECT_TRUE(A.Get(SERVER_VERSION) == 20);
-
-    Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(B.good());
-    EXPECT_TRUE(B.Get(IS_UNSYNCED) == false);
-    EXPECT_TRUE(B.Get(IS_UNAPPLIED_UPDATE) == false);
-    EXPECT_TRUE(B.Get(SERVER_VERSION) == 20);
-  }
-}
-
-TEST_F(SyncerTest, ConflictMatchingEntryHandlesNormalNames) {
-  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
-  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
-  mock_server_->set_conflict_all_commits(true);
-  SyncShareAsDelegate();
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-
-    MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(A.good());
-    A.Put(IS_UNSYNCED, true);
-    A.Put(IS_UNAPPLIED_UPDATE, true);
-    A.Put(SERVER_VERSION, 20);
-
-    MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(B.good());
-    B.Put(IS_UNAPPLIED_UPDATE, true);
-    B.Put(SERVER_VERSION, 20);
-  }
-  LoopSyncShare();
-  saw_syncer_event_ = false;
-  mock_server_->set_conflict_all_commits(false);
-
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-
-    Entry A(&trans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(A.good());
-    EXPECT_TRUE(A.Get(IS_UNSYNCED) == false);
-    EXPECT_TRUE(A.Get(IS_UNAPPLIED_UPDATE) == false);
-    EXPECT_TRUE(A.Get(SERVER_VERSION) == 20);
-
-    Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(B.good());
-    EXPECT_TRUE(B.Get(IS_UNSYNCED) == false);
-    EXPECT_TRUE(B.Get(IS_UNAPPLIED_UPDATE) == false);
-    EXPECT_TRUE(B.Get(SERVER_VERSION) == 20);
-  }
-}
-
-TEST_F(SyncerTest, ReverseFolderOrderingTest) {
-  mock_server_->AddUpdateDirectory(4, 3, "ggchild", 10, 10);
-  mock_server_->AddUpdateDirectory(3, 2, "gchild", 10, 10);
-  mock_server_->AddUpdateDirectory(5, 4, "gggchild", 10, 10);
-  mock_server_->AddUpdateDirectory(2, 1, "child", 10, 10);
-  mock_server_->AddUpdateDirectory(1, 0, "parent", 10, 10);
-  LoopSyncShare();
-  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:
-  void CreateFolderInBob() {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry bob(&trans,
-                     syncable::GET_BY_ID,
-                     GetOnlyEntryWithName(&trans,
-                                          TestIdFactory::root(),
-                                          "bob"));
-    CHECK(bob.good());
-
-    MutableEntry entry2(&trans, syncable::CREATE, bob.Get(syncable::ID),
-                        "bob");
-    CHECK(entry2.good());
-    entry2.Put(syncable::IS_DIR, true);
-    entry2.Put(syncable::IS_UNSYNCED, true);
-    entry2.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-  }
-};
-
-TEST_F(EntryCreatedInNewFolderTest, EntryCreatedInNewFolderMidSync) {
-  directory()->set_store_birthday(mock_server_->store_birthday());
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, syncable::CREATE, trans.root_id(),
-                       "bob");
-    ASSERT_TRUE(entry.good());
-    entry.Put(syncable::IS_DIR, true);
-    entry.Put(syncable::IS_UNSYNCED, true);
-    entry.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-  }
-
-  mock_server_->SetMidCommitCallback(
-      base::Bind(&EntryCreatedInNewFolderTest::CreateFolderInBob,
-                 base::Unretained(this)));
-  syncer_->SyncShare(session_.get(), BUILD_COMMIT_REQUEST, SYNCER_END);
-  EXPECT_EQ(1u, mock_server_->committed_ids().size());
-  {
-    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.Get(ID), "bob");
-    Entry child(&trans, syncable::GET_BY_ID, child_id);
-    ASSERT_TRUE(child.good());
-    EXPECT_EQ(parent_entry.Get(ID), child.Get(PARENT_ID));
-}
-}
-
-TEST_F(SyncerTest, NegativeIDInUpdate) {
-  mock_server_->AddUpdateBookmark(-10, 0, "bad", 40, 40);
-  SyncShareAsDelegate();
-  // The negative id would make us CHECK!
-}
-
-TEST_F(SyncerTest, UnappliedUpdateOnCreatedItemItemDoesNotCrash) {
-  int64 metahandle_fred;
-  {
-    // Create an item.
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry fred_match(&trans, CREATE, trans.root_id(),
-                            "fred_match");
-    ASSERT_TRUE(fred_match.good());
-    metahandle_fred = fred_match.Get(META_HANDLE);
-    WriteTestDataToEntry(&trans, &fred_match);
-  }
-  // Commit it.
-  SyncShareAsDelegate();
-  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.Get(ID).ServerKnows());
-    fred_match_id = fred_match.Get(ID);
-    mock_server_->AddUpdateBookmark(fred_match_id, trans.root_id(),
-        "fred_match", 40, 40);
-  }
-  // Run the syncer.
-  for (int i = 0 ; i < 30 ; ++i) {
-    SyncShareAsDelegate();
-  }
-}
-
-/**
- * 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) {
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans, syncable::CREATE, root_id_, "Folder");
-    ASSERT_TRUE(parent.good());
-    parent.Put(syncable::IS_DIR, true);
-    parent.Put(syncable::ID, parent_id_);
-    parent.Put(syncable::BASE_VERSION, 5);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    MutableEntry child(&wtrans, syncable::CREATE, parent_id_, "Pete.htm");
-    ASSERT_TRUE(child.good());
-    child.Put(syncable::ID, child_id_);
-    child.Put(syncable::BASE_VERSION, 10);
-    WriteTestDataToEntry(&wtrans, &child);
-  }
-  mock_server_->AddUpdateBookmark(child_id_, parent_id_, "Pete2.htm", 11, 10);
-  mock_server_->set_conflict_all_commits(true);
-  LoopSyncShare();
-  syncable::Directory::ChildHandles children;
-  {
-    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.Get(syncable::IS_UNSYNCED));
-    EXPECT_FALSE(child.Get(syncable::IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(child.Get(SPECIFICS).has_bookmark());
-    EXPECT_EQ("Pete.htm", child.Get(NON_UNIQUE_NAME));
-    VerifyTestBookmarkDataInEntry(&child);
-  }
-
-  // Only one entry, since we just overwrite one.
-  EXPECT_EQ(1u, children.size());
-  saw_syncer_event_ = false;
-}
-
-// We got this repro case when someone was editing bookmarks while sync was
-// occuring. The entry had changed out underneath the user.
-TEST_F(SyncerTest, CommitsUpdateDoesntAlterEntry) {
-  const base::Time& test_time = ProtoTimeToTime(123456);
-  int64 entry_metahandle;
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&wtrans, syncable::CREATE, root_id_, "Pete");
-    ASSERT_TRUE(entry.good());
-    EXPECT_FALSE(entry.Get(ID).ServerKnows());
-    entry.Put(syncable::IS_DIR, true);
-    entry.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    entry.Put(syncable::IS_UNSYNCED, true);
-    entry.Put(syncable::MTIME, test_time);
-    entry_metahandle = entry.Get(META_HANDLE);
-  }
-  SyncShareAsDelegate();
-  syncable::Id id;
-  int64 version;
-  int64 server_position_in_parent;
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, syncable::GET_BY_HANDLE, entry_metahandle);
-    ASSERT_TRUE(entry.good());
-    id = entry.Get(ID);
-    EXPECT_TRUE(id.ServerKnows());
-    version = entry.Get(BASE_VERSION);
-    server_position_in_parent = entry.Get(SERVER_POSITION_IN_PARENT);
-  }
-  sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
-  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_EQ(server_position_in_parent, update->position_in_parent());
-  SyncShareAsDelegate();
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, syncable::GET_BY_ID, id);
-    ASSERT_TRUE(entry.good());
-    EXPECT_TRUE(entry.Get(MTIME) == test_time);
-  }
-}
-
-TEST_F(SyncerTest, ParentAndChildBothMatch) {
-  const syncable::FullModelTypeSet all_types =
-      syncable::FullModelTypeSet::All();
-  syncable::Id parent_id = ids_.NewServerId();
-  syncable::Id child_id = ids_.NewServerId();
-
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans, CREATE, root_id_, "Folder");
-    ASSERT_TRUE(parent.good());
-    parent.Put(IS_DIR, true);
-    parent.Put(IS_UNSYNCED, true);
-    parent.Put(ID, parent_id);
-    parent.Put(BASE_VERSION, 1);
-    parent.Put(SPECIFICS, DefaultBookmarkSpecifics());
-
-    MutableEntry child(&wtrans, CREATE, parent.Get(ID), "test.htm");
-    ASSERT_TRUE(child.good());
-    child.Put(ID, child_id);
-    child.Put(BASE_VERSION, 1);
-    child.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    WriteTestDataToEntry(&wtrans, &child);
-  }
-  mock_server_->AddUpdateDirectory(parent_id, root_id_, "Folder", 10, 10);
-  mock_server_->AddUpdateBookmark(child_id, parent_id, "test.htm", 10, 10);
-  mock_server_->set_conflict_all_commits(true);
-  SyncShareAsDelegate();
-  SyncShareAsDelegate();
-  SyncShareAsDelegate();
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Directory::ChildHandles children;
-    directory()->GetChildHandlesById(&trans, root_id_, &children);
-    EXPECT_EQ(1u, children.size());
-    directory()->GetChildHandlesById(&trans, parent_id, &children);
-    EXPECT_EQ(1u, children.size());
-    Directory::UnappliedUpdateMetaHandles unapplied;
-    directory()->GetUnappliedUpdateMetaHandles(&trans, all_types, &unapplied);
-    EXPECT_EQ(0u, unapplied.size());
-    syncable::Directory::UnsyncedMetaHandles 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, trans.root_id(), "bob");
-    entry.Put(IS_UNSYNCED, true);
-    entry.Put(IS_DEL, true);
-  }
-  SyncShareAsDelegate();
-  EXPECT_EQ(0u, mock_server_->committed_ids().size());
-}
-
-// Original problem synopsis:
-// Check failed: entry->Get(BASE_VERSION) <= entry->Get(SERVER_VERSION)
-// 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, trans.root_id(), "bob");
-    entry.Put(ID, ids_.FromNumber(20));
-    entry.Put(BASE_VERSION, 1);
-    entry.Put(SERVER_VERSION, 1);
-    entry.Put(SERVER_PARENT_ID, ids_.FromNumber(9999));  // Bad parent.
-    entry.Put(IS_UNSYNCED, true);
-    entry.Put(IS_UNAPPLIED_UPDATE, true);
-    entry.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    entry.Put(SERVER_SPECIFICS, DefaultBookmarkSpecifics());
-    entry.Put(IS_DEL, false);
-  }
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  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, trans.root_id(), "existing");
-    ASSERT_TRUE(entry.good());
-    entry.Put(IS_DIR, true);
-    entry.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    entry.Put(IS_UNSYNCED, true);
-    existing_metahandle = entry.Get(META_HANDLE);
-  }
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry newfolder(&trans, CREATE, trans.root_id(), "new");
-    ASSERT_TRUE(newfolder.good());
-    newfolder.Put(IS_DIR, true);
-    newfolder.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    newfolder.Put(IS_UNSYNCED, true);
-
-    MutableEntry existing(&trans, GET_BY_HANDLE, existing_metahandle);
-    ASSERT_TRUE(existing.good());
-    existing.Put(PARENT_ID, newfolder.Get(ID));
-    existing.Put(IS_UNSYNCED, true);
-    EXPECT_TRUE(existing.Get(ID).ServerKnows());
-
-    newfolder.Put(IS_DEL, true);
-    existing.Put(IS_DEL, true);
-  }
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  const StatusController& status(session_->status_controller());
-  EXPECT_EQ(0, status.TotalNumServerConflictingItems());
-}
-
-TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
-  int64 newfolder_metahandle;
-
-  mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
-  SyncShareAsDelegate();
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry newfolder(&trans, CREATE, ids_.FromNumber(1), "local");
-    ASSERT_TRUE(newfolder.good());
-    newfolder.Put(IS_UNSYNCED, true);
-    newfolder.Put(IS_DIR, true);
-    newfolder.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    newfolder_metahandle = newfolder.Get(META_HANDLE);
-  }
-  mock_server_->AddUpdateDirectory(1, 0, "bob", 2, 20);
-  mock_server_->SetLastUpdateDeleted();
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, APPLY_UPDATES);
-  {
-    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);
-  mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10);
-  SyncShareAsDelegate();
-  mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20);
-  mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20);
-  SyncShareAsDelegate();
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
-    ASSERT_TRUE(id1.good());
-    EXPECT_TRUE("fred" == id1.Get(NON_UNIQUE_NAME));
-    EXPECT_TRUE(root_id_ == id1.Get(PARENT_ID));
-    Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
-    ASSERT_TRUE(id2.good());
-    EXPECT_TRUE("bob" == id2.Get(NON_UNIQUE_NAME));
-    EXPECT_TRUE(root_id_ == id2.Get(PARENT_ID));
-  }
-  saw_syncer_event_ = false;
-}
-
-TEST_F(SyncerTest, NameCollidingFolderSwapWorksFine) {
-  mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10);
-  mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10);
-  mock_server_->AddUpdateDirectory(4096, 0, "alice", 1, 10);
-  SyncShareAsDelegate();
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
-    ASSERT_TRUE(id1.good());
-    EXPECT_TRUE("bob" == id1.Get(NON_UNIQUE_NAME));
-    EXPECT_TRUE(root_id_ == id1.Get(PARENT_ID));
-    Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
-    ASSERT_TRUE(id2.good());
-    EXPECT_TRUE("fred" == id2.Get(NON_UNIQUE_NAME));
-    EXPECT_TRUE(root_id_ == id2.Get(PARENT_ID));
-    Entry id3(&trans, GET_BY_ID, ids_.FromNumber(4096));
-    ASSERT_TRUE(id3.good());
-    EXPECT_TRUE("alice" == id3.Get(NON_UNIQUE_NAME));
-    EXPECT_TRUE(root_id_ == id3.Get(PARENT_ID));
-  }
-  mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20);
-  mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20);
-  mock_server_->AddUpdateDirectory(4096, 0, "bob", 2, 20);
-  SyncShareAsDelegate();
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
-    ASSERT_TRUE(id1.good());
-    EXPECT_TRUE("fred" == id1.Get(NON_UNIQUE_NAME));
-    EXPECT_TRUE(root_id_ == id1.Get(PARENT_ID));
-    Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
-    ASSERT_TRUE(id2.good());
-    EXPECT_TRUE("bob" == id2.Get(NON_UNIQUE_NAME));
-    EXPECT_TRUE(root_id_ == id2.Get(PARENT_ID));
-    Entry id3(&trans, GET_BY_ID, ids_.FromNumber(4096));
-    ASSERT_TRUE(id3.good());
-    EXPECT_TRUE("bob" == id3.Get(NON_UNIQUE_NAME));
-    EXPECT_TRUE(root_id_ == id3.Get(PARENT_ID));
-  }
-  saw_syncer_event_ = false;
-}
-
-TEST_F(SyncerTest, CommitManyItemsInOneGo) {
-  uint32 max_batches = 3;
-  uint32 items_to_commit = kDefaultMaxCommitBatchSize * max_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, trans.root_id(), name);
-      e.Put(IS_UNSYNCED, true);
-      e.Put(IS_DIR, true);
-      e.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    }
-  }
-  uint32 num_loops = 0;
-  while (SyncShareAsDelegate()) {
-    num_loops++;
-    ASSERT_LT(num_loops, max_batches * 2);
-  }
-  EXPECT_GE(mock_server_->commit_messages().size(), max_batches);
-}
-
-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();
-      tree_ids.push_back(next_id);
-      mock_server_->AddUpdateDirectory(next_id, last_id, "BOB", 2, 20);
-      last_id = next_id;
-    }
-  }
-  SyncShareAsDelegate();
-
-  // Check they're in the expected conflict state.
-  {
-    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.Get(IS_DEL));
-      EXPECT_TRUE(e.Get(IS_UNAPPLIED_UPDATE));
-    }
-  }
-
-  // Add the missing parent directory.
-  mock_server_->AddUpdateDirectory(parent_id, TestIdFactory::root(),
-      "BOB", 2, 20);
-  SyncShareAsDelegate();
-
-  // Now they should all be OK.
-  {
-    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.Get(IS_DEL));
-      EXPECT_FALSE(e.Get(IS_UNAPPLIED_UPDATE));
-    }
-  }
-}
-
-TEST_F(SyncerTest, DontCrashOnCaseChange) {
-  mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
-  SyncShareAsDelegate();
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry e(&trans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(e.good());
-    e.Put(IS_UNSYNCED, true);
-  }
-  mock_server_->set_conflict_all_commits(true);
-  mock_server_->AddUpdateDirectory(1, 0, "BOB", 2, 20);
-  SyncShareAsDelegate();  // USED TO CAUSE AN ASSERT
-  saw_syncer_event_ = false;
-}
-
-TEST_F(SyncerTest, UnsyncedItemAndUpdate) {
-  mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
-  SyncShareAsDelegate();
-  mock_server_->set_conflict_all_commits(true);
-  mock_server_->AddUpdateDirectory(2, 0, "bob", 2, 20);
-  SyncShareAsDelegate();  // USED TO CAUSE AN ASSERT
-  saw_syncer_event_ = false;
-}
-
-TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath) {
-  mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10);
-  SyncShareAsDelegate();
-  int64 local_folder_handle;
-  syncable::Id local_folder_id;
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry new_entry(&wtrans, CREATE, wtrans.root_id(), "Bar.htm");
-    ASSERT_TRUE(new_entry.good());
-    local_folder_id = new_entry.Get(ID);
-    local_folder_handle = new_entry.Get(META_HANDLE);
-    new_entry.Put(IS_UNSYNCED, true);
-    new_entry.Put(SPECIFICS, 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);
-  mock_server_->set_conflict_all_commits(true);
-  SyncShareAsDelegate();
-  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.Get(META_HANDLE) != server.Get(META_HANDLE));
-    EXPECT_FALSE(server.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(local.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(server.Get(IS_UNSYNCED));
-    EXPECT_TRUE(local.Get(IS_UNSYNCED));
-    EXPECT_EQ("Foo.htm", server.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ("Bar.htm", local.Get(NON_UNIQUE_NAME));
-  }
-  // Allow local changes to commit.
-  mock_server_->set_conflict_all_commits(false);
-  SyncShareAsDelegate();
-  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);
-  SyncShareAsDelegate();
-  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.Get(META_HANDLE) != server.Get(META_HANDLE));
-    EXPECT_FALSE(server.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(local.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(server.Get(IS_UNSYNCED));
-    EXPECT_FALSE(local.Get(IS_UNSYNCED));
-    EXPECT_EQ("Bar.htm", server.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ("Bar.htm", local.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
-        server.Get(SPECIFICS).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);
-  SyncShareAsDelegate();
-  int64 local_folder_handle;
-  syncable::Id local_folder_id;
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry new_entry(&wtrans, CREATE, wtrans.root_id(), "Bar.htm");
-    ASSERT_TRUE(new_entry.good());
-    local_folder_id = new_entry.Get(ID);
-    local_folder_handle = new_entry.Get(META_HANDLE);
-    new_entry.Put(IS_UNSYNCED, true);
-    new_entry.Put(SPECIFICS, 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);
-  mock_server_->set_conflict_all_commits(true);
-  SyncShareAsDelegate();
-  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.Get(META_HANDLE) != server.Get(META_HANDLE));
-    EXPECT_FALSE(server.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(local.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(server.Get(IS_UNSYNCED));
-    EXPECT_TRUE(local.Get(IS_UNSYNCED));
-    EXPECT_EQ("Foo.htm", server.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ("Bar.htm", local.Get(NON_UNIQUE_NAME));
-  }
-  // Allow local changes to commit.
-  mock_server_->set_conflict_all_commits(false);
-  SyncShareAsDelegate();
-  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);
-  SyncShareAsDelegate();
-  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.Get(META_HANDLE) != server.Get(META_HANDLE));
-    EXPECT_FALSE(server.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(local.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(server.Get(IS_UNSYNCED));
-    EXPECT_FALSE(local.Get(IS_UNSYNCED));
-    EXPECT_EQ("Bar.htm", server.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ("Bar.htm", local.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
-        server.Get(SPECIFICS).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);
-  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
-  SyncShareAsDelegate();
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(A.good());
-    A.Put(IS_UNSYNCED, true);
-    ASSERT_TRUE(A.Put(PARENT_ID, ids_.FromNumber(2)));
-    ASSERT_TRUE(A.Put(NON_UNIQUE_NAME, "B"));
-  }
-  mock_server_->AddUpdateDirectory(2, 1, "A", 20, 20);
-  mock_server_->set_conflict_all_commits(true);
-  SyncShareAsDelegate();
-  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.Get(NON_UNIQUE_NAME) == "B");
-    EXPECT_TRUE(B.Get(NON_UNIQUE_NAME) == "B");
-  }
-}
-
-TEST_F(SyncerTest, SwapEntryNames) {
-  // Simple transaction test.
-  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
-  mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
-  mock_server_->set_conflict_all_commits(true);
-  SyncShareAsDelegate();
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(A.good());
-    A.Put(IS_UNSYNCED, true);
-    MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(B.good());
-    B.Put(IS_UNSYNCED, true);
-    ASSERT_TRUE(A.Put(NON_UNIQUE_NAME, "C"));
-    ASSERT_TRUE(B.Put(NON_UNIQUE_NAME, "A"));
-    ASSERT_TRUE(A.Put(NON_UNIQUE_NAME, "B"));
-  }
-  SyncShareAsDelegate();
-  saw_syncer_event_ = false;
-}
-
-TEST_F(SyncerTest, DualDeletionWithNewItemNameClash) {
-  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
-  mock_server_->AddUpdateBookmark(2, 0, "B", 10, 10);
-  mock_server_->set_conflict_all_commits(true);
-  SyncShareAsDelegate();
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry B(&trans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(B.good());
-    WriteTestDataToEntry(&trans, &B);
-    B.Put(IS_DEL, true);
-  }
-  mock_server_->AddUpdateBookmark(2, 0, "A", 11, 11);
-  mock_server_->SetLastUpdateDeleted();
-  SyncShareAsDelegate();
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(B.good());
-    EXPECT_FALSE(B.Get(IS_UNSYNCED));
-    EXPECT_FALSE(B.Get(IS_UNAPPLIED_UPDATE));
-  }
-  saw_syncer_event_ = false;
-}
-
-TEST_F(SyncerTest, ResolveWeWroteTheyDeleted) {
-  int64 bob_metahandle;
-
-  mock_server_->AddUpdateBookmark(1, 0, "bob", 1, 10);
-  SyncShareAsDelegate();
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
-    ASSERT_TRUE(bob.good());
-    bob_metahandle = bob.Get(META_HANDLE);
-    WriteTestDataToEntry(&trans, &bob);
-  }
-  mock_server_->AddUpdateBookmark(1, 0, "bob", 2, 10);
-  mock_server_->SetLastUpdateDeleted();
-  mock_server_->set_conflict_all_commits(true);
-  SyncShareAsDelegate();
-  SyncShareAsDelegate();
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry bob(&trans, GET_BY_HANDLE, bob_metahandle);
-    ASSERT_TRUE(bob.good());
-    EXPECT_TRUE(bob.Get(IS_UNSYNCED));
-    EXPECT_FALSE(bob.Get(ID).ServerKnows());
-    EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(bob.Get(IS_DEL));
-  }
-  saw_syncer_event_ = false;
-}
-
-// This test is to reproduce a check failure. Sometimes we would get a bad ID
-// back when creating an entry.
-TEST_F(SyncerTest, DuplicateIDReturn) {
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry folder(&trans, CREATE, trans.root_id(), "bob");
-    ASSERT_TRUE(folder.good());
-    folder.Put(IS_UNSYNCED, true);
-    folder.Put(IS_DIR, true);
-    folder.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    MutableEntry folder2(&trans, CREATE, trans.root_id(), "fred");
-    ASSERT_TRUE(folder2.good());
-    folder2.Put(IS_UNSYNCED, false);
-    folder2.Put(IS_DIR, true);
-    folder2.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    folder2.Put(BASE_VERSION, 3);
-    folder2.Put(ID, 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).
-  SyncShareAsDelegate();
-  EXPECT_EQ(1u, directory()->unsynced_entity_count());
-  SyncShareAsDelegate();  // 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);
-  SyncShareAsDelegate();
-  {
-    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.Put(PARENT_ID, ids_.FromNumber(54));
-    bob.Put(IS_DEL, true);
-    bob.Put(IS_UNSYNCED, true);
-  }
-  mock_server_->AddUpdateDirectory(2, 1, "fred", 1, 10);
-  SyncShareAsDelegate();
-  SyncShareAsDelegate();
-}
-
-TEST_F(SyncerTest, ConflictResolverMergesLocalDeleteAndServerUpdate) {
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-
-    MutableEntry local_deleted(&trans, CREATE, trans.root_id(), "name");
-    local_deleted.Put(ID, ids_.FromNumber(1));
-    local_deleted.Put(BASE_VERSION, 1);
-    local_deleted.Put(IS_DEL, true);
-    local_deleted.Put(IS_DIR, false);
-    local_deleted.Put(IS_UNSYNCED, true);
-    local_deleted.Put(SPECIFICS, DefaultBookmarkSpecifics());
-  }
-
-  mock_server_->AddUpdateBookmark(ids_.FromNumber(1), root_id_, "name", 10, 10);
-
-  // We don't care about actually committing, just the resolution.
-  mock_server_->set_conflict_all_commits(true);
-  SyncShareAsDelegate();
-
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry local_deleted(&trans, GET_BY_ID, ids_.FromNumber(1));
-    EXPECT_TRUE(local_deleted.Get(BASE_VERSION) == 10);
-    EXPECT_TRUE(local_deleted.Get(IS_UNAPPLIED_UPDATE) == false);
-    EXPECT_TRUE(local_deleted.Get(IS_UNSYNCED) == true);
-    EXPECT_TRUE(local_deleted.Get(IS_DEL) == true);
-    EXPECT_TRUE(local_deleted.Get(IS_DIR) == false);
-  }
-}
-
-// See what happens if the IS_DIR bit gets flipped.  This can cause us
-// all kinds of disasters.
-TEST_F(SyncerTest, UpdateFlipsTheFolderBit) {
-  // Local object: a deleted directory (container), revision 1, unsynced.
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-
-    MutableEntry local_deleted(&trans, CREATE, trans.root_id(), "name");
-    local_deleted.Put(ID, ids_.FromNumber(1));
-    local_deleted.Put(BASE_VERSION, 1);
-    local_deleted.Put(IS_DEL, true);
-    local_deleted.Put(IS_DIR, true);
-    local_deleted.Put(IS_UNSYNCED, true);
-    local_deleted.Put(SPECIFICS, DefaultBookmarkSpecifics());
-  }
-
-  // Server update: entry-type object (not a container), revision 10.
-  mock_server_->AddUpdateBookmark(ids_.FromNumber(1), root_id_, "name", 10, 10);
-
-  // Don't attempt to commit.
-  mock_server_->set_conflict_all_commits(true);
-
-  // The syncer should not attempt to apply the invalid update.
-  SyncShareAsDelegate();
-
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry local_deleted(&trans, GET_BY_ID, ids_.FromNumber(1));
-    EXPECT_TRUE(local_deleted.Get(BASE_VERSION) == 1);
-    EXPECT_TRUE(local_deleted.Get(IS_UNAPPLIED_UPDATE) == false);
-    EXPECT_TRUE(local_deleted.Get(IS_UNSYNCED) == true);
-    EXPECT_TRUE(local_deleted.Get(IS_DEL) == true);
-    EXPECT_TRUE(local_deleted.Get(IS_DIR) == 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);
-  SyncShareAsDelegate();
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, CREATE, trans.root_id(), "Copy of base");
-    WriteTestDataToEntry(&trans, &entry);
-  }
-  mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50);
-  SyncRepeatedlyToTriggerConflictResolution(session_.get());
-}
-
-// 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);
-  mock_server_->SetChangesRemaining(depth - 1);
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-
-  // 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);
-  }
-
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-
-  // Ensure our folder hasn't somehow applied.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry child(&trans, GET_BY_ID, stuck_entry_id);
-    EXPECT_TRUE(child.good());
-    EXPECT_TRUE(child.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(child.Get(IS_DEL));
-    EXPECT_FALSE(child.Get(IS_UNSYNCED));
-  }
-
-  // And finally the folder.
-  mock_server_->AddUpdateDirectory(folder_id,
-      TestIdFactory::root(), "folder", 1, 1);
-  mock_server_->SetChangesRemaining(0);
-  LoopSyncShare();
-  LoopSyncShare();
-  // Check that everything is as expected after the commit.
-  {
-    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.Get(ID), child.Get(PARENT_ID));
-    EXPECT_EQ("stuck", child.Get(NON_UNIQUE_NAME));
-    EXPECT_TRUE(child.good());
-  }
-}
-
-TEST_F(SyncerTest, DontMergeTwoExistingItems) {
-  mock_server_->set_conflict_all_commits(true);
-  mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10);
-  mock_server_->AddUpdateBookmark(2, 0, "base2", 10, 10);
-  SyncShareAsDelegate();
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(entry.good());
-    EXPECT_TRUE(entry.Put(NON_UNIQUE_NAME, "Copy of base"));
-    entry.Put(IS_UNSYNCED, true);
-  }
-  mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50);
-  SyncRepeatedlyToTriggerConflictResolution(session_.get());
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry1(&trans, GET_BY_ID, ids_.FromNumber(1));
-    EXPECT_FALSE(entry1.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(entry1.Get(IS_UNSYNCED));
-    EXPECT_FALSE(entry1.Get(IS_DEL));
-    Entry entry2(&trans, GET_BY_ID, ids_.FromNumber(2));
-    EXPECT_FALSE(entry2.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(entry2.Get(IS_UNSYNCED));
-    EXPECT_FALSE(entry2.Get(IS_DEL));
-    EXPECT_EQ(entry1.Get(NON_UNIQUE_NAME), entry2.Get(NON_UNIQUE_NAME));
-  }
-}
-
-TEST_F(SyncerTest, TestUndeleteUpdate) {
-  mock_server_->set_conflict_all_commits(true);
-  mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1);
-  mock_server_->AddUpdateDirectory(2, 1, "bar", 1, 2);
-  SyncShareAsDelegate();
-  mock_server_->AddUpdateDirectory(2, 1, "bar", 2, 3);
-  mock_server_->SetLastUpdateDeleted();
-  SyncShareAsDelegate();
-
-  int64 metahandle;
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(entry.good());
-    EXPECT_TRUE(entry.Get(IS_DEL));
-    metahandle = entry.Get(META_HANDLE);
-  }
-  mock_server_->AddUpdateDirectory(1, 0, "foo", 2, 4);
-  mock_server_->SetLastUpdateDeleted();
-  SyncShareAsDelegate();
-  // 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);
-  SyncShareAsDelegate();
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(entry.good());
-    EXPECT_TRUE(entry.Get(IS_DEL));
-    EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
-    EXPECT_TRUE(entry.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_NE(entry.Get(META_HANDLE), metahandle);
-  }
-}
-
-TEST_F(SyncerTest, TestMoveSanitizedNamedFolder) {
-  mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1);
-  mock_server_->AddUpdateDirectory(2, 0, ":::", 1, 2);
-  SyncShareAsDelegate();
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(entry.good());
-    EXPECT_TRUE(entry.Put(PARENT_ID, ids_.FromNumber(1)));
-    EXPECT_TRUE(entry.Put(IS_UNSYNCED, true));
-  }
-  SyncShareAsDelegate();
-  // We use the same sync ts as before so our times match up.
-  mock_server_->AddUpdateDirectory(2, 1, ":::", 2, 2);
-  SyncShareAsDelegate();
-}
-
-// Don't crash when this occurs.
-TEST_F(SyncerTest, UpdateWhereParentIsNotAFolder) {
-  mock_server_->AddUpdateBookmark(1, 0, "B", 10, 10);
-  mock_server_->AddUpdateDirectory(2, 1, "BookmarkParent", 10, 10);
-  // Used to cause a CHECK
-  SyncShareAsDelegate();
-  {
-    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.Get(IS_UNAPPLIED_UPDATE));
-    Entry bad_parent(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(2));
-    ASSERT_TRUE(bad_parent.good());
-    EXPECT_TRUE(bad_parent.Get(IS_UNAPPLIED_UPDATE));
-  }
-}
-
-const char kRootId[] = "0";
-
-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);
-  mock_server_->AddUpdateDirectory(in_in_root_id, in_root_id,
-                                   "in_in_root_name", 3, 3);
-  SyncShareAsDelegate();
-  {
-    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.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(TestIdFactory::root(), in_root.Get(PARENT_ID));
-
-    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.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(in_root_id, in_in_root.Get(PARENT_ID));
-  }
-}
-
-TEST_F(SyncerTest, DirectoryCommitTest) {
-  syncable::Id in_root_id, in_dir_id;
-  int64 foo_metahandle;
-  int64 bar_metahandle;
-
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry parent(&wtrans, syncable::CREATE, root_id_, "foo");
-    ASSERT_TRUE(parent.good());
-    parent.Put(syncable::IS_UNSYNCED, true);
-    parent.Put(syncable::IS_DIR, true);
-    parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    in_root_id = parent.Get(syncable::ID);
-    foo_metahandle = parent.Get(META_HANDLE);
-
-    MutableEntry child(&wtrans, syncable::CREATE, parent.Get(ID), "bar");
-    ASSERT_TRUE(child.good());
-    child.Put(syncable::IS_UNSYNCED, true);
-    child.Put(syncable::IS_DIR, true);
-    child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
-    bar_metahandle = child.Get(META_HANDLE);
-    in_dir_id = parent.Get(syncable::ID);
-  }
-  SyncShareAsDelegate();
-  {
-    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.Get(NON_UNIQUE_NAME));
-    EXPECT_NE(foo_entry.Get(syncable::ID), in_root_id);
-
-    Entry bar_entry(&trans, GET_BY_HANDLE, bar_metahandle);
-    ASSERT_TRUE(bar_entry.good());
-    EXPECT_EQ("bar", bar_entry.Get(NON_UNIQUE_NAME));
-    EXPECT_NE(bar_entry.Get(syncable::ID), in_dir_id);
-    EXPECT_EQ(foo_entry.Get(syncable::ID), bar_entry.Get(PARENT_ID));
-  }
-}
-
-TEST_F(SyncerTest, TestClientCommand) {
-  using sync_pb::ClientCommand;
-
-  ClientCommand* command = mock_server_->GetNextClientCommand();
-  command->set_set_sync_poll_interval(8);
-  command->set_set_sync_long_poll_interval(800);
-  command->set_sessions_commit_delay_seconds(3141);
-  mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1);
-  SyncShareAsDelegate();
-
-  EXPECT_TRUE(TimeDelta::FromSeconds(8) ==
-              last_short_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(800) ==
-              last_long_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(3141) ==
-              last_sessions_commit_delay_seconds_);
-
-  command = mock_server_->GetNextClientCommand();
-  command->set_set_sync_poll_interval(180);
-  command->set_set_sync_long_poll_interval(190);
-  command->set_sessions_commit_delay_seconds(2718);
-  mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1);
-  SyncShareAsDelegate();
-
-  EXPECT_TRUE(TimeDelta::FromSeconds(180) ==
-              last_short_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(190) ==
-              last_long_poll_interval_received_);
-  EXPECT_TRUE(TimeDelta::FromSeconds(2718) ==
-              last_sessions_commit_delay_seconds_);
-}
-
-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);
-  mock_server_->AddUpdateDirectory(folder_two_id, TestIdFactory::root(),
-      "folder_two", 1, 1);
-  SyncShareAsDelegate();
-  {
-    // 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.Put(PARENT_ID, folder_two_id);
-    entry.Put(IS_UNSYNCED, true);
-    // A new entry should send no "old parent."
-    MutableEntry create(&trans, CREATE, trans.root_id(), "new_folder");
-    create.Put(IS_UNSYNCED, true);
-    create.Put(SPECIFICS, DefaultBookmarkSpecifics());
-  }
-  SyncShareAsDelegate();
-  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");
-  int64 item_metahandle;
-
-  // Try writing max int64 to the version fields of a meta entry.
-  {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&wtrans, syncable::CREATE, wtrans.root_id(), name);
-    ASSERT_TRUE(entry.good());
-    entry.Put(syncable::BASE_VERSION, really_big_int);
-    entry.Put(syncable::SERVER_VERSION, really_big_int);
-    entry.Put(syncable::ID, ids_.NewServerId());
-    item_metahandle = entry.Get(META_HANDLE);
-  }
-  // Now read it back out and make sure the value is max int64.
-  ReadTransaction rtrans(FROM_HERE, directory());
-  Entry entry(&rtrans, syncable::GET_BY_HANDLE, item_metahandle);
-  ASSERT_TRUE(entry.good());
-  EXPECT_TRUE(really_big_int == entry.Get(syncable::BASE_VERSION));
-}
-
-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);
-  SyncShareAsDelegate();
-  // 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.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(entry.Get(IS_UNSYNCED));
-    EXPECT_FALSE(entry.Get(IS_DEL));
-    // Delete it locally.
-    entry.Put(IS_DEL, true);
-  }
-  SyncShareAsDelegate();
-  // Confirm we see IS_DEL and not SERVER_IS_DEL.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_ID, id);
-    ASSERT_TRUE(entry.good());
-    EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(entry.Get(IS_UNSYNCED));
-    EXPECT_TRUE(entry.Get(IS_DEL));
-    EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
-  }
-  SyncShareAsDelegate();
-  // Update from server confirming deletion.
-  mock_server_->AddUpdateBookmark(id, root, "foo", 2, 11);
-  mock_server_->SetLastUpdateDeleted();
-  SyncShareAsDelegate();
-  // IS_DEL AND SERVER_IS_DEL now both true.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_ID, id);
-    ASSERT_TRUE(entry.good());
-    EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(entry.Get(IS_UNSYNCED));
-    EXPECT_TRUE(entry.Get(IS_DEL));
-    EXPECT_TRUE(entry.Get(SERVER_IS_DEL));
-  }
-  // Undelete from server.
-  mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12);
-  SyncShareAsDelegate();
-  // IS_DEL and SERVER_IS_DEL now both false.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_ID, id);
-    ASSERT_TRUE(entry.good());
-    EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(entry.Get(IS_UNSYNCED));
-    EXPECT_FALSE(entry.Get(IS_DEL));
-    EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
-  }
-}
-
-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);
-  SyncShareAsDelegate();
-  // 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.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(entry.Get(IS_UNSYNCED));
-    EXPECT_FALSE(entry.Get(IS_DEL));
-    // Delete it locally.
-    entry.Put(IS_DEL, true);
-  }
-  SyncShareAsDelegate();
-  // Confirm we see IS_DEL and not SERVER_IS_DEL.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_ID, id);
-    ASSERT_TRUE(entry.good());
-    EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(entry.Get(IS_UNSYNCED));
-    EXPECT_TRUE(entry.Get(IS_DEL));
-    EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
-  }
-  SyncShareAsDelegate();
-  // Say we do not get an update from server confirming deletion. Undelete
-  // from server
-  mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12);
-  SyncShareAsDelegate();
-  // IS_DEL and SERVER_IS_DEL now both false.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_ID, id);
-    ASSERT_TRUE(entry.good());
-    EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(entry.Get(IS_UNSYNCED));
-    EXPECT_FALSE(entry.Get(IS_DEL));
-    EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
-  }
-}
-
-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);
-  mock_server_->AddUpdateBookmark(id2, root, "foo", 1, 10);
-  SyncShareAsDelegate();
-  mock_server_->AddUpdateBookmark(id2, root, "foo2", 2, 20);
-  SyncShareAsDelegate();  // Now just don't explode.
-}
-
-TEST_F(SyncerTest, ClientTagServerCreatedUpdatesWork) {
-  mock_server_->AddUpdateDirectory(1, 0, "permitem1", 1, 10);
-  mock_server_->SetLastUpdateClientTag("permfolder");
-
-  SyncShareAsDelegate();
-
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
-    ASSERT_TRUE(perm_folder.good());
-    EXPECT_FALSE(perm_folder.Get(IS_DEL));
-    EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(perm_folder.Get(IS_UNSYNCED));
-    EXPECT_EQ(perm_folder.Get(UNIQUE_CLIENT_TAG), "permfolder");
-    EXPECT_EQ(perm_folder.Get(NON_UNIQUE_NAME), "permitem1");
-  }
-
-  mock_server_->AddUpdateDirectory(1, 0, "permitem_renamed", 10, 100);
-  mock_server_->SetLastUpdateClientTag("permfolder");
-  SyncShareAsDelegate();
-
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-
-    Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
-    ASSERT_TRUE(perm_folder.good());
-    EXPECT_FALSE(perm_folder.Get(IS_DEL));
-    EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(perm_folder.Get(IS_UNSYNCED));
-    EXPECT_EQ(perm_folder.Get(UNIQUE_CLIENT_TAG), "permfolder");
-    EXPECT_EQ(perm_folder.Get(NON_UNIQUE_NAME), "permitem_renamed");
-  }
-}
-
-TEST_F(SyncerTest, ClientTagIllegalUpdateIgnored) {
-  mock_server_->AddUpdateDirectory(1, 0, "permitem1", 1, 10);
-  mock_server_->SetLastUpdateClientTag("permfolder");
-
-  SyncShareAsDelegate();
-
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
-    ASSERT_TRUE(perm_folder.good());
-    EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(perm_folder.Get(IS_UNSYNCED));
-    EXPECT_EQ(perm_folder.Get(UNIQUE_CLIENT_TAG), "permfolder");
-    EXPECT_TRUE(perm_folder.Get(NON_UNIQUE_NAME) == "permitem1");
-    EXPECT_TRUE(perm_folder.Get(ID).ServerKnows());
-  }
-
-  mock_server_->AddUpdateDirectory(1, 0, "permitem_renamed", 10, 100);
-  mock_server_->SetLastUpdateClientTag("wrongtag");
-  SyncShareAsDelegate();
-
-  {
-    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());
-
-    Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
-    ASSERT_TRUE(perm_folder.good());
-    EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(perm_folder.Get(IS_UNSYNCED));
-    EXPECT_EQ(perm_folder.Get(NON_UNIQUE_NAME), "permitem1");
-  }
-}
-
-TEST_F(SyncerTest, ClientTagUncommittedTagMatchesUpdate) {
-  int64 original_metahandle = 0;
-
-  sync_pb::EntitySpecifics local_bookmark(DefaultBookmarkSpecifics());
-  local_bookmark.mutable_bookmark()->set_url("http://foo/localsite");
-  sync_pb::EntitySpecifics server_bookmark(DefaultBookmarkSpecifics());
-  server_bookmark.mutable_bookmark()->set_url("http://bar/serversite");
-
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry perm_folder(&trans, CREATE, ids_.root(), "clientname");
-    ASSERT_TRUE(perm_folder.good());
-    perm_folder.Put(UNIQUE_CLIENT_TAG, "clientperm");
-    perm_folder.Put(SPECIFICS, local_bookmark);
-    perm_folder.Put(IS_UNSYNCED, true);
-    EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(perm_folder.Get(ID).ServerKnows());
-    original_metahandle = perm_folder.Get(META_HANDLE);
-  }
-
-  mock_server_->AddUpdateBookmark(1, 0, "permitem_renamed", 10, 100);
-  mock_server_->SetLastUpdateClientTag("clientperm");
-  mock_server_->GetMutableLastUpdate()->mutable_specifics()->
-      CopyFrom(server_bookmark);
-  mock_server_->set_conflict_all_commits(true);
-
-  SyncShareAsDelegate();
-  // This should cause client tag reunion, preserving the metahandle.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-
-    Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "clientperm");
-    ASSERT_TRUE(perm_folder.good());
-    EXPECT_FALSE(perm_folder.Get(IS_DEL));
-    EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(perm_folder.Get(IS_UNSYNCED));
-    EXPECT_EQ(10, perm_folder.Get(BASE_VERSION));
-    // Entry should have been given the new ID while preserving the
-    // metahandle; client should have won the conflict resolution.
-    EXPECT_EQ(original_metahandle, perm_folder.Get(META_HANDLE));
-    EXPECT_EQ("clientperm", perm_folder.Get(UNIQUE_CLIENT_TAG));
-    EXPECT_EQ("clientname", perm_folder.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(local_bookmark.SerializeAsString(),
-              perm_folder.Get(SPECIFICS).SerializeAsString());
-    EXPECT_TRUE(perm_folder.Get(ID).ServerKnows());
-  }
-
-  mock_server_->set_conflict_all_commits(false);
-  SyncShareAsDelegate();
-
-  // The resolved entry ought to commit cleanly.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-
-    Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "clientperm");
-    ASSERT_TRUE(perm_folder.good());
-    EXPECT_FALSE(perm_folder.Get(IS_DEL));
-    EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(perm_folder.Get(IS_UNSYNCED));
-    EXPECT_TRUE(10 < perm_folder.Get(BASE_VERSION));
-    // Entry should have been given the new ID while preserving the
-    // metahandle; client should have won the conflict resolution.
-    EXPECT_EQ(original_metahandle, perm_folder.Get(META_HANDLE));
-    EXPECT_EQ("clientperm", perm_folder.Get(UNIQUE_CLIENT_TAG));
-    EXPECT_EQ("clientname", perm_folder.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(local_bookmark.SerializeAsString(),
-              perm_folder.Get(SPECIFICS).SerializeAsString());
-    EXPECT_TRUE(perm_folder.Get(ID).ServerKnows());
-  }
-}
-
-TEST_F(SyncerTest, ClientTagConflictWithDeletedLocalEntry) {
-  {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry perm_folder(&trans, CREATE, ids_.root(), "clientname");
-    ASSERT_TRUE(perm_folder.good());
-    ASSERT_FALSE(perm_folder.Get(ID).ServerKnows());
-    perm_folder.Put(UNIQUE_CLIENT_TAG, "clientperm");
-    perm_folder.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    perm_folder.Put(IS_UNSYNCED, true);
-    perm_folder.Put(IS_DEL, true);
-  }
-
-  mock_server_->AddUpdateDirectory(1, 0, "permitem_renamed", 10, 100);
-  mock_server_->SetLastUpdateClientTag("clientperm");
-  mock_server_->set_conflict_all_commits(true);
-
-  SyncShareAsDelegate();
-  // This should cause client tag overwrite.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-
-    Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "clientperm");
-    ASSERT_TRUE(perm_folder.good());
-    ASSERT_TRUE(perm_folder.Get(ID).ServerKnows());
-    EXPECT_TRUE(perm_folder.Get(IS_DEL));
-    EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(perm_folder.Get(IS_UNSYNCED));
-    EXPECT_EQ(perm_folder.Get(BASE_VERSION), 10);
-    EXPECT_EQ(perm_folder.Get(UNIQUE_CLIENT_TAG), "clientperm");
-  }
-}
-
-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));
-
-  mock_server_->AddUpdateBookmark(1, 0, "One", 10, 100);
-  mock_server_->SetLastUpdateClientTag("tag1");
-  mock_server_->AddUpdateBookmark(4, 0, "Four", 11, 110);
-  mock_server_->SetLastUpdateClientTag("tag2");
-
-  mock_server_->set_conflict_all_commits(true);
-
-  SyncShareAsDelegate();
-  int64 tag1_metahandle = syncable::kInvalidMetaHandle;
-  int64 tag2_metahandle = syncable::kInvalidMetaHandle;
-  // This should cause client tag overwrite.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-
-    Entry tag1(&trans, GET_BY_CLIENT_TAG, "tag1");
-    ASSERT_TRUE(tag1.good());
-    ASSERT_TRUE(tag1.Get(ID).ServerKnows());
-    ASSERT_TRUE(ids_.FromNumber(1) == tag1.Get(ID));
-    EXPECT_FALSE(tag1.Get(IS_DEL));
-    EXPECT_FALSE(tag1.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(tag1.Get(IS_UNSYNCED));
-    EXPECT_EQ("One", tag1.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(10, tag1.Get(BASE_VERSION));
-    EXPECT_EQ("tag1", tag1.Get(UNIQUE_CLIENT_TAG));
-    tag1_metahandle = tag1.Get(META_HANDLE);
-
-    Entry tag2(&trans, GET_BY_CLIENT_TAG, "tag2");
-    ASSERT_TRUE(tag2.good());
-    ASSERT_TRUE(tag2.Get(ID).ServerKnows());
-    ASSERT_TRUE(ids_.FromNumber(4) == tag2.Get(ID));
-    EXPECT_FALSE(tag2.Get(IS_DEL));
-    EXPECT_FALSE(tag2.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(tag2.Get(IS_UNSYNCED));
-    EXPECT_EQ("Four", tag2.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(11, tag2.Get(BASE_VERSION));
-    EXPECT_EQ("tag2", tag2.Get(UNIQUE_CLIENT_TAG));
-    tag2_metahandle = tag2.Get(META_HANDLE);
-
-    syncable::Directory::ChildHandles children;
-    directory()->GetChildHandlesById(&trans, trans.root_id(), &children);
-    ASSERT_EQ(2U, children.size());
-  }
-
-  mock_server_->AddUpdateBookmark(2, 0, "Two", 12, 120);
-  mock_server_->SetLastUpdateClientTag("tag1");
-  mock_server_->AddUpdateBookmark(3, 0, "Three", 13, 130);
-  mock_server_->SetLastUpdateClientTag("tag2");
-  SyncShareAsDelegate();
-
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-
-    Entry tag1(&trans, GET_BY_CLIENT_TAG, "tag1");
-    ASSERT_TRUE(tag1.good());
-    ASSERT_TRUE(tag1.Get(ID).ServerKnows());
-    ASSERT_TRUE(ids_.FromNumber(1) == tag1.Get(ID))
-        << "ID 1 should be kept, since it was less than ID 2.";
-    EXPECT_FALSE(tag1.Get(IS_DEL));
-    EXPECT_FALSE(tag1.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(tag1.Get(IS_UNSYNCED));
-    EXPECT_EQ(10, tag1.Get(BASE_VERSION));
-    EXPECT_EQ("tag1", tag1.Get(UNIQUE_CLIENT_TAG));
-    EXPECT_EQ("One", tag1.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(tag1_metahandle, tag1.Get(META_HANDLE));
-
-    Entry tag2(&trans, GET_BY_CLIENT_TAG, "tag2");
-    ASSERT_TRUE(tag2.good());
-    ASSERT_TRUE(tag2.Get(ID).ServerKnows());
-    ASSERT_TRUE(ids_.FromNumber(3) == tag2.Get(ID))
-        << "ID 3 should be kept, since it was less than ID 4.";
-    EXPECT_FALSE(tag2.Get(IS_DEL));
-    EXPECT_FALSE(tag2.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(tag2.Get(IS_UNSYNCED));
-    EXPECT_EQ("Three", tag2.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(13, tag2.Get(BASE_VERSION));
-    EXPECT_EQ("tag2", tag2.Get(UNIQUE_CLIENT_TAG));
-    EXPECT_EQ(tag2_metahandle, tag2.Get(META_HANDLE));
-
-    syncable::Directory::ChildHandles children;
-    directory()->GetChildHandlesById(&trans, trans.root_id(), &children);
-    ASSERT_EQ(2U, children.size());
-  }
-}
-
-TEST_F(SyncerTest, ClientTagClashWithinBatchOfUpdates) {
-  // This test is written assuming that ID comparison
-  // will work out in a particular way.
-  EXPECT_TRUE(ids_.FromNumber(1) < ids_.FromNumber(4));
-  EXPECT_TRUE(ids_.FromNumber(201) < ids_.FromNumber(205));
-
-  mock_server_->AddUpdateBookmark(1, 0, "One A", 1, 10);
-  mock_server_->SetLastUpdateClientTag("tag a");  // Least ID: winner.
-  mock_server_->AddUpdateBookmark(2, 0, "Two A", 11, 110);
-  mock_server_->SetLastUpdateClientTag("tag a");
-  mock_server_->AddUpdateBookmark(3, 0, "Three A", 12, 120);
-  mock_server_->SetLastUpdateClientTag("tag a");
-  mock_server_->AddUpdateBookmark(4, 0, "Four A", 13, 130);
-  mock_server_->SetLastUpdateClientTag("tag a");
-
-  mock_server_->AddUpdateBookmark(105, 0, "One B", 14, 140);
-  mock_server_->SetLastUpdateClientTag("tag b");
-  mock_server_->AddUpdateBookmark(102, 0, "Two B", 15, 150);
-  mock_server_->SetLastUpdateClientTag("tag b");
-  mock_server_->AddUpdateBookmark(101, 0, "Three B", 16, 160);
-  mock_server_->SetLastUpdateClientTag("tag b");  // Least ID: winner.
-  mock_server_->AddUpdateBookmark(104, 0, "Four B", 17, 170);
-  mock_server_->SetLastUpdateClientTag("tag b");
-
-  mock_server_->AddUpdateBookmark(205, 0, "One C", 18, 180);
-  mock_server_->SetLastUpdateClientTag("tag c");
-  mock_server_->AddUpdateBookmark(202, 0, "Two C", 19, 190);
-  mock_server_->SetLastUpdateClientTag("tag c");
-  mock_server_->AddUpdateBookmark(204, 0, "Three C", 20, 200);
-  mock_server_->SetLastUpdateClientTag("tag c");
-  mock_server_->AddUpdateBookmark(201, 0, "Four C", 21, 210);
-  mock_server_->SetLastUpdateClientTag("tag c");  // Least ID: winner.
-
-  mock_server_->set_conflict_all_commits(true);
-
-  SyncShareAsDelegate();
-  // This should cause client tag overwrite.
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-
-    Entry tag_a(&trans, GET_BY_CLIENT_TAG, "tag a");
-    ASSERT_TRUE(tag_a.good());
-    EXPECT_TRUE(tag_a.Get(ID).ServerKnows());
-    EXPECT_EQ(ids_.FromNumber(1), tag_a.Get(ID));
-    EXPECT_FALSE(tag_a.Get(IS_DEL));
-    EXPECT_FALSE(tag_a.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(tag_a.Get(IS_UNSYNCED));
-    EXPECT_EQ("One A", tag_a.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(1, tag_a.Get(BASE_VERSION));
-    EXPECT_EQ("tag a", tag_a.Get(UNIQUE_CLIENT_TAG));
-
-    Entry tag_b(&trans, GET_BY_CLIENT_TAG, "tag b");
-    ASSERT_TRUE(tag_b.good());
-    EXPECT_TRUE(tag_b.Get(ID).ServerKnows());
-    EXPECT_EQ(ids_.FromNumber(101), tag_b.Get(ID));
-    EXPECT_FALSE(tag_b.Get(IS_DEL));
-    EXPECT_FALSE(tag_b.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(tag_b.Get(IS_UNSYNCED));
-    EXPECT_EQ("Three B", tag_b.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(16, tag_b.Get(BASE_VERSION));
-    EXPECT_EQ("tag b", tag_b.Get(UNIQUE_CLIENT_TAG));
-
-    Entry tag_c(&trans, GET_BY_CLIENT_TAG, "tag c");
-    ASSERT_TRUE(tag_c.good());
-    EXPECT_TRUE(tag_c.Get(ID).ServerKnows());
-    EXPECT_EQ(ids_.FromNumber(201), tag_c.Get(ID));
-    EXPECT_FALSE(tag_c.Get(IS_DEL));
-    EXPECT_FALSE(tag_c.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(tag_c.Get(IS_UNSYNCED));
-    EXPECT_EQ("Four C", tag_c.Get(NON_UNIQUE_NAME));
-    EXPECT_EQ(21, tag_c.Get(BASE_VERSION));
-    EXPECT_EQ("tag c", tag_c.Get(UNIQUE_CLIENT_TAG));
-
-    syncable::Directory::ChildHandles children;
-    directory()->GetChildHandlesById(&trans, trans.root_id(), &children);
-    ASSERT_EQ(3U, children.size());
-  }
-}
-
-TEST_F(SyncerTest, UniqueServerTagUpdates) {
-  // As a hurdle, introduce an item whose name is the same as the tag value
-  // we'll use later.
-  int64 hurdle_handle = CreateUnsyncedDirectory("bob", "id_bob");
-  {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry hurdle(&trans, GET_BY_HANDLE, hurdle_handle);
-    ASSERT_TRUE(hurdle.good());
-    ASSERT_TRUE(!hurdle.Get(IS_DEL));
-    ASSERT_TRUE(hurdle.Get(UNIQUE_SERVER_TAG).empty());
-    ASSERT_TRUE(hurdle.Get(NON_UNIQUE_NAME) == "bob");
-
-    // Try to lookup by the tagname.  These should fail.
-    Entry tag_alpha(&trans, GET_BY_SERVER_TAG, "alpha");
-    EXPECT_FALSE(tag_alpha.good());
-    Entry tag_bob(&trans, GET_BY_SERVER_TAG, "bob");
-    EXPECT_FALSE(tag_bob.good());
-  }
-
-  // Now download some tagged items as updates.
-  mock_server_->AddUpdateDirectory(1, 0, "update1", 1, 10);
-  mock_server_->SetLastUpdateServerTag("alpha");
-  mock_server_->AddUpdateDirectory(2, 0, "update2", 2, 20);
-  mock_server_->SetLastUpdateServerTag("bob");
-  SyncShareAsDelegate();
-
-  {
-    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.Get(IS_DEL));
-    ASSERT_TRUE(tag_alpha.Get(UNIQUE_SERVER_TAG) == "alpha");
-    ASSERT_TRUE(tag_alpha.Get(NON_UNIQUE_NAME) == "update1");
-    Entry tag_bob(&trans, GET_BY_SERVER_TAG, "bob");
-    ASSERT_TRUE(tag_bob.good());
-    ASSERT_TRUE(!tag_bob.Get(IS_DEL));
-    ASSERT_TRUE(tag_bob.Get(UNIQUE_SERVER_TAG) == "bob");
-    ASSERT_TRUE(tag_bob.Get(NON_UNIQUE_NAME) == "update2");
-    // The old item should be unchanged.
-    Entry hurdle(&trans, GET_BY_HANDLE, hurdle_handle);
-    ASSERT_TRUE(hurdle.good());
-    ASSERT_TRUE(!hurdle.Get(IS_DEL));
-    ASSERT_TRUE(hurdle.Get(UNIQUE_SERVER_TAG).empty());
-    ASSERT_TRUE(hurdle.Get(NON_UNIQUE_NAME) == "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(syncable::BOOKMARKS);
-  SyncShareAsDelegate();
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-
-  EnableDatatype(syncable::AUTOFILL);
-  SyncShareAsDelegate();
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-
-  EnableDatatype(syncable::PREFERENCES);
-  SyncShareAsDelegate();
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-
-  DisableDatatype(syncable::BOOKMARKS);
-  SyncShareAsDelegate();
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-
-  DisableDatatype(syncable::AUTOFILL);
-  SyncShareAsDelegate();
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-
-  DisableDatatype(syncable::PREFERENCES);
-  EnableDatatype(syncable::AUTOFILL);
-  SyncShareAsDelegate();
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-}
-
-// 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.
-//
-// In cases of ordering A-F below, the outcome should be the same.
-//   Exercised by UndeleteDuringCommit:
-//     A. Delete - commit - undelete - commitresponse.
-//     B. Delete - commit - undelete - commitresponse - getupdates.
-//   Exercised by UndeleteBeforeCommit:
-//     C. Delete - undelete - commit - commitresponse.
-//     D. Delete - undelete - commit - commitresponse - getupdates.
-//   Exercised by UndeleteAfterCommit:
-//     E. Delete - commit - commitresponse - undelete - commit
-//        - commitresponse.
-//     F. Delete - commit - commitresponse - undelete - commit -
-//        - commitresponse - getupdates.
-class SyncerUndeletionTest : public SyncerTest {
- public:
-  SyncerUndeletionTest()
-      : client_tag_("foobar"),
-        metahandle_(syncable::kInvalidMetaHandle) {
-  }
-
-  void Create() {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry perm_folder(&trans, CREATE, ids_.root(), "clientname");
-    ASSERT_TRUE(perm_folder.good());
-    perm_folder.Put(UNIQUE_CLIENT_TAG, client_tag_);
-    perm_folder.Put(IS_UNSYNCED, true);
-    perm_folder.Put(SYNCING, false);
-    perm_folder.Put(SPECIFICS, DefaultBookmarkSpecifics());
-    EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
-    EXPECT_FALSE(perm_folder.Get(ID).ServerKnows());
-    metahandle_ = perm_folder.Get(META_HANDLE);
-  }
-
-  void Delete() {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, GET_BY_CLIENT_TAG, client_tag_);
-    ASSERT_TRUE(entry.good());
-    EXPECT_EQ(metahandle_, entry.Get(META_HANDLE));
-    entry.Put(IS_DEL, true);
-    entry.Put(IS_UNSYNCED, true);
-    entry.Put(SYNCING, false);
-  }
-
-  void Undelete() {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
-    MutableEntry entry(&trans, GET_BY_CLIENT_TAG, client_tag_);
-    ASSERT_TRUE(entry.good());
-    EXPECT_EQ(metahandle_, entry.Get(META_HANDLE));
-    EXPECT_TRUE(entry.Get(IS_DEL));
-    entry.Put(IS_DEL, false);
-    entry.Put(IS_UNSYNCED, true);
-    entry.Put(SYNCING, false);
-  }
-
-  int64 GetMetahandleOfTag() {
-    ReadTransaction trans(FROM_HERE, directory());
-    Entry entry(&trans, GET_BY_CLIENT_TAG, client_tag_);
-    EXPECT_TRUE(entry.good());
-    if (!entry.good()) {
-      return syncable::kInvalidMetaHandle;
-    }
-    return entry.Get(META_HANDLE);
-  }
-
-  void ExpectUnsyncedCreation() {
-    EXPECT_EQ(metahandle_, GetMetahandleOfTag());
-    EXPECT_FALSE(Get(metahandle_, IS_DEL));
-    EXPECT_FALSE(Get(metahandle_, SERVER_IS_DEL));  // Never been committed.
-    EXPECT_GE(0, Get(metahandle_, BASE_VERSION));
-    EXPECT_TRUE(Get(metahandle_, IS_UNSYNCED));
-    EXPECT_FALSE(Get(metahandle_, IS_UNAPPLIED_UPDATE));
-  }
-
-  void ExpectUnsyncedUndeletion() {
-    EXPECT_EQ(metahandle_, GetMetahandleOfTag());
-    EXPECT_FALSE(Get(metahandle_, IS_DEL));
-    EXPECT_TRUE(Get(metahandle_, SERVER_IS_DEL));
-    EXPECT_EQ(0, Get(metahandle_, BASE_VERSION));
-    EXPECT_TRUE(Get(metahandle_, IS_UNSYNCED));
-    EXPECT_FALSE(Get(metahandle_, IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(Get(metahandle_, ID).ServerKnows());
-  }
-
-  void ExpectUnsyncedEdit() {
-    EXPECT_EQ(metahandle_, GetMetahandleOfTag());
-    EXPECT_FALSE(Get(metahandle_, IS_DEL));
-    EXPECT_FALSE(Get(metahandle_, SERVER_IS_DEL));
-    EXPECT_LT(0, Get(metahandle_, BASE_VERSION));
-    EXPECT_TRUE(Get(metahandle_, IS_UNSYNCED));
-    EXPECT_FALSE(Get(metahandle_, IS_UNAPPLIED_UPDATE));
-    EXPECT_TRUE(Get(metahandle_, ID).ServerKnows());
-  }
-
-  void ExpectUnsyncedDeletion() {
-    EXPECT_EQ(metahandle_, GetMetahandleOfTag());
-    EXPECT_TRUE(Get(metahandle_, IS_DEL));
-    EXPECT_FALSE(Get(metahandle_, SERVER_IS_DEL));
-    EXPECT_TRUE(Get(metahandle_, IS_UNSYNCED));
-    EXPECT_FALSE(Get(metahandle_, IS_UNAPPLIED_UPDATE));
-    EXPECT_LT(0, Get(metahandle_, BASE_VERSION));
-    EXPECT_LT(0, Get(metahandle_, SERVER_VERSION));
-  }
-
-  void ExpectSyncedAndCreated() {
-    EXPECT_EQ(metahandle_, GetMetahandleOfTag());
-    EXPECT_FALSE(Get(metahandle_, IS_DEL));
-    EXPECT_FALSE(Get(metahandle_, SERVER_IS_DEL));
-    EXPECT_LT(0, Get(metahandle_, BASE_VERSION));
-    EXPECT_EQ(Get(metahandle_, BASE_VERSION), Get(metahandle_, SERVER_VERSION));
-    EXPECT_FALSE(Get(metahandle_, IS_UNSYNCED));
-    EXPECT_FALSE(Get(metahandle_, IS_UNAPPLIED_UPDATE));
-  }
-
-  void ExpectSyncedAndDeleted() {
-    EXPECT_EQ(metahandle_, GetMetahandleOfTag());
-    EXPECT_TRUE(Get(metahandle_, IS_DEL));
-    EXPECT_TRUE(Get(metahandle_, SERVER_IS_DEL));
-    EXPECT_FALSE(Get(metahandle_, IS_UNSYNCED));
-    EXPECT_FALSE(Get(metahandle_, IS_UNAPPLIED_UPDATE));
-    EXPECT_GE(0, Get(metahandle_, BASE_VERSION));
-    EXPECT_GE(0, Get(metahandle_, SERVER_VERSION));
-  }
-
- protected:
-  const std::string client_tag_;
-  int64 metahandle_;
-};
-
-TEST_F(SyncerUndeletionTest, UndeleteDuringCommit) {
-  Create();
-  ExpectUnsyncedCreation();
-  SyncShareAsDelegate();
-
-  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)));
-  SyncShareAsDelegate();
-
-  // The item ought to exist as an unsynced undeletion (meaning,
-  // we think that the next commit ought to be a recreation commit).
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  ExpectUnsyncedUndeletion();
-
-  // 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());
-  mock_server_->AddUpdateTombstone(Get(metahandle_, ID));
-  SyncShareAsDelegate();
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  ExpectSyncedAndCreated();
-}
-
-TEST_F(SyncerUndeletionTest, UndeleteBeforeCommit) {
-  Create();
-  ExpectUnsyncedCreation();
-  SyncShareAsDelegate();
-
-  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.
-  SyncShareAsDelegate();
-
-  // The item ought to have committed successfully.
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  ExpectSyncedAndCreated();
-  EXPECT_EQ(2, Get(metahandle_, BASE_VERSION));
-
-  // Now, encounter a GetUpdates corresponding to the just-committed
-  // update.
-  mock_server_->AddUpdateFromLastCommit();
-  SyncShareAsDelegate();
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  ExpectSyncedAndCreated();
-}
-
-TEST_F(SyncerUndeletionTest, UndeleteAfterCommitButBeforeGetUpdates) {
-  Create();
-  ExpectUnsyncedCreation();
-  SyncShareAsDelegate();
-
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  ExpectSyncedAndCreated();
-
-  // Delete and commit.
-  Delete();
-  ExpectUnsyncedDeletion();
-  SyncShareAsDelegate();
-
-  // 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();
-  SyncShareAsDelegate();
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  ExpectSyncedAndCreated();
-}
-
-TEST_F(SyncerUndeletionTest, UndeleteAfterDeleteAndGetUpdates) {
-  Create();
-  ExpectUnsyncedCreation();
-  SyncShareAsDelegate();
-
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  ExpectSyncedAndCreated();
-
-  mock_server_->AddUpdateFromLastCommit();
-  SyncShareAsDelegate();
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  ExpectSyncedAndCreated();
-
-  // Delete and commit.
-  Delete();
-  ExpectUnsyncedDeletion();
-  SyncShareAsDelegate();
-
-  // 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();
-  SyncShareAsDelegate();
-  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.
-  SyncShareAsDelegate();
-  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();
-  SyncShareAsDelegate();
-
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  ExpectSyncedAndCreated();
-
-  // Add a delete from the server.
-  mock_server_->AddUpdateFromLastCommit();
-  SyncShareAsDelegate();
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  ExpectSyncedAndCreated();
-
-  // Some other client deletes the item.
-  mock_server_->AddUpdateTombstone(Get(metahandle_, ID));
-  SyncShareAsDelegate();
-
-  // 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();
-  SyncShareAsDelegate();
-  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.
-  mock_server_->AddUpdateFromLastCommit();
-  SyncShareAsDelegate();
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  ExpectSyncedAndCreated();
-}
-
-TEST_F(SyncerUndeletionTest, UndeleteAfterOtherClientDeletesImmediately) {
-  Create();
-  ExpectUnsyncedCreation();
-  SyncShareAsDelegate();
-
-  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.
-  mock_server_->AddUpdateTombstone(Get(metahandle_, ID));
-  SyncShareAsDelegate();
-
-  // 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();
-  SyncShareAsDelegate();
-  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.
-  mock_server_->AddUpdateFromLastCommit();
-  SyncShareAsDelegate();
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  ExpectSyncedAndCreated();
-}
-
-TEST_F(SyncerUndeletionTest, OtherClientUndeletes) {
-  Create();
-  ExpectUnsyncedCreation();
-  SyncShareAsDelegate();
-
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  ExpectSyncedAndCreated();
-
-  // Get the updates of our just-committed entry.
-  mock_server_->AddUpdateFromLastCommit();
-  SyncShareAsDelegate();
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  ExpectSyncedAndCreated();
-
-  // We delete the item.
-  Delete();
-  ExpectUnsyncedDeletion();
-  SyncShareAsDelegate();
-
-  // 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();
-  SyncShareAsDelegate();
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  ExpectSyncedAndDeleted();
-
-  // Some other client undeletes the item.
-  mock_server_->AddUpdateBookmark(Get(metahandle_, ID),
-                                  Get(metahandle_, PARENT_ID),
-                                  "Thadeusz", 100, 1000);
-  mock_server_->SetLastUpdateClientTag(client_tag_);
-  SyncShareAsDelegate();
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  ExpectSyncedAndCreated();
-  EXPECT_EQ("Thadeusz", Get(metahandle_, NON_UNIQUE_NAME));
-}
-
-TEST_F(SyncerUndeletionTest, OtherClientUndeletesImmediately) {
-  Create();
-  ExpectUnsyncedCreation();
-  SyncShareAsDelegate();
-
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  ExpectSyncedAndCreated();
-
-  // Get the updates of our just-committed entry.
-  mock_server_->AddUpdateFromLastCommit();
-  SyncShareAsDelegate();
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  ExpectSyncedAndCreated();
-
-  // We delete the item.
-  Delete();
-  ExpectUnsyncedDeletion();
-  SyncShareAsDelegate();
-
-  // 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.
-  mock_server_->AddUpdateBookmark(Get(metahandle_, ID),
-                                  Get(metahandle_, PARENT_ID),
-                                  "Thadeusz", 100, 1000);
-  mock_server_->SetLastUpdateClientTag(client_tag_);
-  SyncShareAsDelegate();
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
-  EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  ExpectSyncedAndCreated();
-  EXPECT_EQ("Thadeusz", Get(metahandle_, NON_UNIQUE_NAME));
-}
-
-// A group of tests exercising the syncer's handling of sibling ordering, as
-// represented in the sync protocol.
-class SyncerPositionUpdateTest : public SyncerTest {
- public:
-  SyncerPositionUpdateTest() : next_update_id_(1), next_revision_(1) {}
-
- protected:
-  void ExpectLocalItemsInServerOrder() {
-    if (position_map_.empty())
-      return;
-
-    ReadTransaction trans(FROM_HERE, directory());
-
-    Id prev_id;
-    DCHECK(prev_id.IsRoot());
-    PosMap::iterator next = position_map_.begin();
-    for (PosMap::iterator i = next++; i != position_map_.end(); ++i) {
-      Id id = i->second;
-      Entry entry_with_id(&trans, GET_BY_ID, id);
-      EXPECT_TRUE(entry_with_id.good());
-      EXPECT_EQ(prev_id, entry_with_id.Get(PREV_ID));
-      EXPECT_EQ(i->first, entry_with_id.Get(SERVER_POSITION_IN_PARENT));
-      if (next == position_map_.end()) {
-        EXPECT_EQ(Id(), entry_with_id.Get(NEXT_ID));
-      } else {
-        EXPECT_EQ(next->second, entry_with_id.Get(NEXT_ID));
-        next++;
-      }
-      prev_id = id;
-    }
-  }
-
-  void AddRootItemWithPosition(int64 position) {
-    string id = string("ServerId") + base::Int64ToString(next_update_id_++);
-    string name = "my name is my id -- " + id;
-    int revision = next_revision_++;
-    mock_server_->AddUpdateDirectory(id, kRootId, name, revision, revision);
-    mock_server_->SetLastUpdatePosition(position);
-    position_map_.insert(
-        PosMap::value_type(position, Id::CreateFromServerId(id)));
-  }
- private:
-  typedef multimap<int64, Id> PosMap;
-  PosMap position_map_;
-  int next_update_id_;
-  int next_revision_;
-  DISALLOW_COPY_AND_ASSIGN(SyncerPositionUpdateTest);
-};
-
-TEST_F(SyncerPositionUpdateTest, InOrderPositive) {
-  // Add a bunch of items in increasing order, starting with just positive
-  // position values.
-  AddRootItemWithPosition(100);
-  AddRootItemWithPosition(199);
-  AddRootItemWithPosition(200);
-  AddRootItemWithPosition(201);
-  AddRootItemWithPosition(400);
-
-  SyncShareAsDelegate();
-  ExpectLocalItemsInServerOrder();
-}
-
-TEST_F(SyncerPositionUpdateTest, InOrderNegative) {
-  // Test negative position values, but in increasing order.
-  AddRootItemWithPosition(-400);
-  AddRootItemWithPosition(-201);
-  AddRootItemWithPosition(-200);
-  AddRootItemWithPosition(-150);
-  AddRootItemWithPosition(100);
-
-  SyncShareAsDelegate();
-  ExpectLocalItemsInServerOrder();
-}
-
-TEST_F(SyncerPositionUpdateTest, ReverseOrder) {
-  // Test when items are sent in the reverse order.
-  AddRootItemWithPosition(400);
-  AddRootItemWithPosition(201);
-  AddRootItemWithPosition(200);
-  AddRootItemWithPosition(100);
-  AddRootItemWithPosition(-150);
-  AddRootItemWithPosition(-201);
-  AddRootItemWithPosition(-200);
-  AddRootItemWithPosition(-400);
-
-  SyncShareAsDelegate();
-  ExpectLocalItemsInServerOrder();
-}
-
-TEST_F(SyncerPositionUpdateTest, RandomOrderInBatches) {
-  // Mix it all up, interleaving position values, and try multiple batches of
-  // updates.
-  AddRootItemWithPosition(400);
-  AddRootItemWithPosition(201);
-  AddRootItemWithPosition(-400);
-  AddRootItemWithPosition(100);
-
-  SyncShareAsDelegate();
-  ExpectLocalItemsInServerOrder();
-
-  AddRootItemWithPosition(-150);
-  AddRootItemWithPosition(-200);
-  AddRootItemWithPosition(200);
-  AddRootItemWithPosition(-201);
-
-  SyncShareAsDelegate();
-  ExpectLocalItemsInServerOrder();
-
-  AddRootItemWithPosition(-144);
-
-  SyncShareAsDelegate();
-  ExpectLocalItemsInServerOrder();
-}
-
-class SyncerPositionTiebreakingTest : public SyncerTest {
- public:
-  SyncerPositionTiebreakingTest()
-      : low_id_(Id::CreateFromServerId("A")),
-        mid_id_(Id::CreateFromServerId("M")),
-        high_id_(Id::CreateFromServerId("Z")),
-        next_revision_(1) {
-    DCHECK(low_id_ < mid_id_);
-    DCHECK(mid_id_ < high_id_);
-    DCHECK(low_id_ < high_id_);
-  }
-
-  // Adds the item by its Id, using a constant value for the position
-  // so that the syncer has to resolve the order some other way.
-  void Add(const Id& id) {
-    int revision = next_revision_++;
-    mock_server_->AddUpdateDirectory(id.GetServerId(), kRootId,
-        id.GetServerId(), revision, revision);
-    // The update position doesn't vary.
-    mock_server_->SetLastUpdatePosition(90210);
-  }
-
-  void ExpectLocalOrderIsByServerId() {
-    ReadTransaction trans(FROM_HERE, directory());
-    Id null_id;
-    Entry low(&trans, GET_BY_ID, low_id_);
-    Entry mid(&trans, GET_BY_ID, mid_id_);
-    Entry high(&trans, GET_BY_ID, high_id_);
-    EXPECT_TRUE(low.good());
-    EXPECT_TRUE(mid.good());
-    EXPECT_TRUE(high.good());
-    EXPECT_TRUE(low.Get(PREV_ID) == null_id);
-    EXPECT_TRUE(mid.Get(PREV_ID) == low_id_);
-    EXPECT_TRUE(high.Get(PREV_ID) == mid_id_);
-    EXPECT_TRUE(high.Get(NEXT_ID) == null_id);
-    EXPECT_TRUE(mid.Get(NEXT_ID) == high_id_);
-    EXPECT_TRUE(low.Get(NEXT_ID) == mid_id_);
-  }
-
- protected:
-  // When there's a tiebreak on the numeric position, it's supposed to be
-  // broken by string comparison of the ids.  These ids are in increasing
-  // order.
-  const Id low_id_;
-  const Id mid_id_;
-  const Id high_id_;
-
- private:
-  int next_revision_;
-  DISALLOW_COPY_AND_ASSIGN(SyncerPositionTiebreakingTest);
-};
-
-TEST_F(SyncerPositionTiebreakingTest, LowMidHigh) {
-  Add(low_id_);
-  Add(mid_id_);
-  Add(high_id_);
-  SyncShareAsDelegate();
-  ExpectLocalOrderIsByServerId();
-}
-
-TEST_F(SyncerPositionTiebreakingTest, LowHighMid) {
-  Add(low_id_);
-  Add(high_id_);
-  Add(mid_id_);
-  SyncShareAsDelegate();
-  ExpectLocalOrderIsByServerId();
-}
-
-TEST_F(SyncerPositionTiebreakingTest, HighMidLow) {
-  Add(high_id_);
-  Add(mid_id_);
-  Add(low_id_);
-  SyncShareAsDelegate();
-  ExpectLocalOrderIsByServerId();
-}
-
-TEST_F(SyncerPositionTiebreakingTest, HighLowMid) {
-  Add(high_id_);
-  Add(low_id_);
-  Add(mid_id_);
-  SyncShareAsDelegate();
-  ExpectLocalOrderIsByServerId();
-}
-
-TEST_F(SyncerPositionTiebreakingTest, MidHighLow) {
-  Add(mid_id_);
-  Add(high_id_);
-  Add(low_id_);
-  SyncShareAsDelegate();
-  ExpectLocalOrderIsByServerId();
-}
-
-TEST_F(SyncerPositionTiebreakingTest, MidLowHigh) {
-  Add(mid_id_);
-  Add(low_id_);
-  Add(high_id_);
-  SyncShareAsDelegate();
-  ExpectLocalOrderIsByServerId();
-}
-
-const SyncerTest::CommitOrderingTest
-SyncerTest::CommitOrderingTest::LAST_COMMIT_ITEM = {-1, TestIdFactory::root()};
-
-}  // namespace browser_sync