[Sync] Start implementation of migration for USS.

components/sync/engine_impl/syncer_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/sync/engine_impl/syncer.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 31 matching lines @@
 #include "components/sync/engine_impl/syncer_proto_util.h"
 #include "components/sync/protocol/bookmark_specifics.pb.h"
 #include "components/sync/protocol/nigori_specifics.pb.h"
 #include "components/sync/protocol/preference_specifics.pb.h"
 #include "components/sync/syncable/mutable_entry.h"
 #include "components/sync/syncable/nigori_util.h"
 #include "components/sync/syncable/syncable_delete_journal.h"
 #include "components/sync/syncable/syncable_read_transaction.h"
 #include "components/sync/syncable/syncable_util.h"
 #include "components/sync/syncable/syncable_write_transaction.h"
+#include "components/sync/syncable/test_user_share.h"
 #include "components/sync/test/engine/fake_model_worker.h"
 #include "components/sync/test/engine/mock_connection_manager.h"
 #include "components/sync/test/engine/mock_nudge_handler.h"
-#include "components/sync/test/engine/test_directory_setter_upper.h"
 #include "components/sync/test/engine/test_id_factory.h"
 #include "components/sync/test/engine/test_syncable_utils.h"
 #include "components/sync/test/fake_sync_encryption_handler.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 using std::count;
 using std::map;
 using std::multimap;
 using std::set;
 using std::string;
 using std::vector;
 
 namespace syncer {
 
-using syncable::BaseTransaction;
 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::WriteTransaction;
 
 using syncable::CREATE;
 using syncable::GET_BY_HANDLE;
 using syncable::GET_BY_ID;
 using syncable::GET_BY_CLIENT_TAG;
 using syncable::GET_BY_SERVER_TAG;
 using syncable::GET_TYPE_ROOT;
 using syncable::UNITTEST;
 
 namespace {
@@ skipping 165 matching lines @@
   }
 
   bool SyncShareConfigure() {
     ResetCycle();
     return syncer_->ConfigureSyncShare(
         context_->GetEnabledTypes(),
         sync_pb::GetUpdatesCallerInfo::RECONFIGURATION, cycle_.get());
   }
 
   void SetUp() override {
-    dir_maker_.SetUp();
+    test_user_share_.SetUp();
     mock_server_ = base::MakeUnique<MockConnectionManager>(
         directory(), &cancelation_signal_);
     debug_info_getter_ = base::MakeUnique<MockDebugInfoGetter>();
     EnableDatatype(BOOKMARKS);
     EnableDatatype(EXTENSIONS);
     EnableDatatype(NIGORI);
     EnableDatatype(PREFERENCES);
     EnableDatatype(NIGORI);
     workers_.push_back(
         scoped_refptr<ModelSafeWorker>(new FakeModelWorker(GROUP_PASSIVE)));
     std::vector<SyncEngineEventListener*> listeners;
     listeners.push_back(this);
 
     ModelSafeRoutingInfo routing_info;
     GetModelSafeRoutingInfo(&routing_info);
 
     model_type_registry_ = base::MakeUnique<ModelTypeRegistry>(
-        workers_, directory(), &mock_nudge_handler_);
+        workers_, test_user_share_.user_share(), &mock_nudge_handler_);
     model_type_registry_->RegisterDirectoryTypeDebugInfoObserver(
         &debug_info_cache_);
 
     context_ = base::MakeUnique<SyncCycleContext>(
         mock_server_.get(), directory(), extensions_activity_.get(), listeners,
         debug_info_getter_.get(), model_type_registry_.get(),
         true,   // enable keystore encryption
         false,  // force enable pre-commit GU avoidance experiment
         "fake_invalidator_client_id");
     context_->SetRoutingInfo(routing_info);
@@ skipping 13 matching lines @@
     child_id_ = ids_.MakeServer("child id");
     directory()->set_store_birthday(mock_server_->store_birthday());
     mock_server_->SetKeystoreKey("encryption_key");
   }
 
   void TearDown() override {
     model_type_registry_->UnregisterDirectoryTypeDebugInfoObserver(
         &debug_info_cache_);
     mock_server_.reset();
     scheduler_.reset();
-    dir_maker_.TearDown();
+    test_user_share_.TearDown();
   }
 
-  void WriteTestDataToEntry(WriteTransaction* trans, MutableEntry* entry) {
+  void WriteTestDataToEntry(syncable::WriteTransaction* trans,
+                            MutableEntry* entry) {
     EXPECT_FALSE(entry->GetIsDir());
     EXPECT_FALSE(entry->GetIsDel());
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_bookmark()->set_url("http://demo/");
     specifics.mutable_bookmark()->set_favicon("PNG");
     entry->PutSpecifics(specifics);
     entry->PutIsUnsynced(true);
   }
-  void VerifyTestDataInEntry(BaseTransaction* trans, Entry* entry) {
+  void VerifyTestDataInEntry(syncable::BaseTransaction* trans, Entry* entry) {
     EXPECT_FALSE(entry->GetIsDir());
     EXPECT_FALSE(entry->GetIsDel());
     VerifyTestBookmarkDataInEntry(entry);
   }
   void VerifyTestBookmarkDataInEntry(Entry* entry) {
     const sync_pb::EntitySpecifics& specifics = entry->GetSpecifics();
     EXPECT_TRUE(specifics.has_bookmark());
     EXPECT_EQ("PNG", specifics.bookmark().favicon());
     EXPECT_EQ("http://demo/", specifics.bookmark().url());
   }
@@ skipping 53 matching lines @@
       CommitOrderingTest last_commit_item;
       last_commit_item.commit_index = -1;
       last_commit_item.id = TestIdFactory::root();
       return last_commit_item;
     }
   };
 
   void RunCommitOrderingTest(CommitOrderingTest* test) {
     map<int, syncable::Id> expected_positions;
     {  // Transaction scope.
-      WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+      syncable::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, BOOKMARKS, test->parent_id, name);
@@ skipping 53 matching lines @@
   }
 
   UpdateCounters GetUpdateCounters(ModelType type) {
     return debug_info_cache_.GetLatestUpdateCounters(type);
   }
 
   StatusCounters GetStatusCounters(ModelType type) {
     return debug_info_cache_.GetLatestStatusCounters(type);
   }
 
-  Directory* directory() { return dir_maker_.directory(); }
+  Directory* directory() {
+    return test_user_share_.user_share()->directory.get();
+  }
 
   const std::string local_cache_guid() { return directory()->cache_guid(); }
 
   const std::string foreign_cache_guid() { return "kqyg7097kro6GSUod+GSg=="; }
 
   int64_t CreateUnsyncedDirectory(const string& entry_name,
                                   const string& idstring) {
     return CreateUnsyncedDirectory(entry_name,
                                    syncable::Id::CreateFromServerId(idstring));
   }
 
   int64_t CreateUnsyncedDirectory(const string& entry_name,
                                   const syncable::Id& id) {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(),
                        entry_name);
     EXPECT_TRUE(entry.good());
     entry.PutIsUnsynced(true);
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutBaseVersion(id.ServerKnows() ? 1 : 0);
     entry.PutId(id);
     return entry.GetMetahandle();
   }
@@ skipping 17 matching lines @@
     ModelSafeRoutingInfo routing_info;
     GetModelSafeRoutingInfo(&routing_info);
 
     if (context_) {
       context_->SetRoutingInfo(routing_info);
     }
 
     mock_server_->ExpectGetUpdatesRequestTypes(enabled_datatypes_);
   }
 
-  Cryptographer* GetCryptographer(BaseTransaction* trans) {
+  Cryptographer* GetCryptographer(syncable::BaseTransaction* trans) {
     return directory()->GetCryptographer(trans);
   }
 
   // Configures SyncCycleContext and NudgeTracker so Syncer won't call
   // GetUpdates prior to Commit. This method can be used to ensure a Commit is
   // not preceeded by GetUpdates.
   void ConfigureNoGetUpdatesRequired() {
     context_->set_server_enabled_pre_commit_update_avoidance(true);
     nudge_tracker_.OnInvalidationsEnabled();
     nudge_tracker_.RecordSuccessfulSyncCycle();
 
     ASSERT_FALSE(context_->ShouldFetchUpdatesBeforeCommit());
     ASSERT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
   }
 
   base::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_;
+  TestUserShare test_user_share_;
   FakeEncryptor encryptor_;
   scoped_refptr<ExtensionsActivity> extensions_activity_;
   std::unique_ptr<MockConnectionManager> mock_server_;
   CancelationSignal cancelation_signal_;
 
   Syncer* syncer_;
 
   std::unique_ptr<SyncCycle> cycle_;
   TypeDebugInfoCache debug_info_cache_;
   MockNudgeHandler mock_nudge_handler_;
@@ skipping 32 matching lines @@
 TEST_F(SyncerTest, GetCommitIdsFiltersThrottledEntries) {
   const ModelTypeSet throttled_types(BOOKMARKS);
   sync_pb::EntitySpecifics bookmark_data;
   AddDefaultFieldValue(BOOKMARKS, &bookmark_data);
 
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10, foreign_cache_guid(),
                                    "-1");
   EXPECT_TRUE(SyncShareNudge());
 
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutSpecifics(bookmark_data);
     A.PutNonUniqueName("bookmark");
   }
 
   // Now sync without enabling bookmarks.
   mock_server_->ExpectGetUpdatesRequestTypes(
       Difference(context_->GetEnabledTypes(), ModelTypeSet(BOOKMARKS)));
@@ skipping 53 matching lines @@
         histogram_tester.GetAllSamples("DataUse.Sync.ProgressMarker.Bytes");
 
     for (const base::Bucket& bucket : samples) {
       if (bucket.min == BOOKMARKS)
         progress_bookmark.at(0) += bucket.count;
       progress_all.at(0) += bucket.count;
     }
     EXPECT_GT(progress_bookmark.at(0), 0u);
     EXPECT_GT(progress_all.at(0), 0u);
 
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     A.PutIsUnsynced(true);
     A.PutSpecifics(bookmark_data);
     A.PutNonUniqueName("bookmark");
   }
 
   // Now sync without enabling bookmarks.
   mock_server_->ExpectGetUpdatesRequestTypes(
       Difference(context_->GetEnabledTypes(), ModelTypeSet(BOOKMARKS)));
   ResetCycle();
@@ skipping 90 matching lines @@
                                    "-3");
   mock_server_->AddUpdateDirectory(4, 0, "D", 10, 10, foreign_cache_guid(),
                                    "-4");
   EXPECT_TRUE(SyncShareNudge());
   // Server side change will put A in conflict.
   mock_server_->AddUpdateDirectory(1, 0, "A", 20, 20, foreign_cache_guid(),
                                    "-1");
   {
     // Mark bookmarks as encrypted and set the cryptographer to have pending
     // keys.
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     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_encryption_keybag());
-    dir_maker_.encryption_handler()->EnableEncryptEverything();
+    test_user_share_.encryption_handler()->EnableEncryptEverything();
     // Set up with an old passphrase, but have pending keys
     GetCryptographer(&wtrans)->AddKey(key_params);
     GetCryptographer(&wtrans)->Encrypt(bookmark,
                                        encrypted_bookmark.mutable_encrypted());
     GetCryptographer(&wtrans)->SetPendingKeys(nigori->encryption_keybag());
 
     // In conflict but properly encrypted.
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
@@ skipping 41 matching lines @@
     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());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry C(&wtrans, GET_BY_ID, ids_.FromNumber(3));
     ASSERT_TRUE(C.good());
     C.PutSpecifics(encrypted_bookmark);
     C.PutNonUniqueName(kEncryptedString);
     MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(D.good());
     D.PutSpecifics(encrypted_bookmark);
     D.PutNonUniqueName(kEncryptedString);
   }
   EXPECT_TRUE(SyncShareNudge());
@@ skipping 43 matching lines @@
   mock_server_->SetThrottledTypes(throttled_types);
 
   mock_server_->AddUpdateSpecifics(1, 0, "E", 20, 20, true, 0, bookmark,
                                    foreign_cache_guid(), "-1");
   mock_server_->AddUpdateSpecifics(2, 1, "F", 20, 20, false, 2, bookmark,
                                    foreign_cache_guid(), "-2");
   mock_server_->AddUpdateSpecifics(3, 1, "G", 20, 20, false, 1, bookmark,
                                    foreign_cache_guid(), "-3");
   mock_server_->AddUpdateSpecifics(4, 0, "H", 20, 20, false, 0, pref);
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     MutableEntry C(&wtrans, GET_BY_ID, ids_.FromNumber(3));
     MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
     A.PutIsUnsynced(true);
     B.PutIsUnsynced(true);
     C.PutIsUnsynced(true);
     D.PutIsUnsynced(true);
   }
   EXPECT_TRUE(SyncShareNudge());
@@ skipping 28 matching lines @@
 }
 
 // This test uses internal knowledge of the directory to test correctness of
 // GetCommitIds.  In almost every other test, the hierarchy is created from
 // parent to child order, and so parents always have metahandles that are
 // smaller than those of their children.  This makes it very difficult to test
 // some GetCommitIds edge cases, since it uses metahandle ordering as
 // a starting point.
 TEST_F(SyncerTest, GetCommitIds_VerifyDeletionCommitOrder) {
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 
     // Create four bookmarks folders at the root node.
     for (int i = 1; i < 5; ++i) {
       MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "");
       entry.PutId(ids_.FromNumber(i));
       entry.PutIsDir(true);
       entry.PutBaseVersion(5);
       entry.PutServerVersion(5);
       entry.PutServerParentId(trans.root_id());
       entry.PutServerIsDir(true);
@@ skipping 33 matching lines @@
 
     Entry entry3(&trans, GET_BY_HANDLE, result_handles[3]);
     EXPECT_EQ(ids_.FromNumber(4), entry3.GetId());
   }
 }
 
 // Verify that if there are more deleted items than the maximum number of
 // entries, child to parent order is still preserved.
 TEST_F(SyncerTest, GetCommitIds_VerifyDeletionCommitOrderMaxEntries) {
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 
     // Create a bookmark tree with one root, two second level, and three third
     // level bookmarks, all folders.
     for (int i = 1; i <= 6; ++i) {
       MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "");
       entry.PutId(ids_.FromNumber(i));
       entry.PutIsDir(true);
       entry.PutBaseVersion(5);
       entry.PutServerVersion(5);
       entry.PutParentId(ids_.FromNumber(i / 2));
@@ skipping 36 matching lines @@
                               modified_bookmark.mutable_encrypted());
   sync_pb::EntitySpecifics pref, encrypted_pref, modified_pref;
   pref.mutable_preference()->set_name("name");
   AddDefaultFieldValue(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());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     sync_pb::EntitySpecifics specifics;
     sync_pb::NigoriSpecifics* nigori = specifics.mutable_nigori();
     other_cryptographer.GetKeys(nigori->mutable_encryption_keybag());
-    dir_maker_.encryption_handler()->EnableEncryptEverything();
+    test_user_share_.encryption_handler()->EnableEncryptEverything();
     GetCryptographer(&wtrans)->SetPendingKeys(nigori->encryption_keybag());
     EXPECT_TRUE(GetCryptographer(&wtrans)->has_pending_keys());
   }
 
   // We need to remember the exact position of our local items, so we can
   // make updates that do not modify those positions.
   UniquePosition pos1;
   UniquePosition pos2;
   UniquePosition pos3;
 
@@ skipping 84 matching lines @@
     // Items 1 is now unencrypted, so should have applied normally.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, false, false, 0, 40, 40, ids_, &rtrans);
     VERIFY_ENTRY(2, true, false, true, 1, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(3, true, false, false, 1, 10, 30, ids_, &rtrans);
     VERIFY_ENTRY(4, true, false, true, 0, 10, 30, ids_, &rtrans);
   }
 
   // Make local changes, which should remain unsynced for items 2, 3, 4.
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutSpecifics(modified_bookmark);
     A.PutNonUniqueName(kEncryptedString);
     A.PutIsUnsynced(true);
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.PutSpecifics(modified_bookmark);
     B.PutNonUniqueName(kEncryptedString);
     B.PutIsUnsynced(true);
@@ skipping 53 matching lines @@
   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, TestGetUnsyncedAndSimpleCommit) {
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Pete");
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutBaseVersion(1);
     parent.PutId(parent_id_);
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent_id_, "Pete");
     ASSERT_TRUE(child.good());
     child.PutId(child_id_);
@@ skipping 15 matching lines @@
 }
 
 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");
   {
     directory()->SetDownloadProgress(BOOKMARKS,
                                      syncable::BuildProgress(BOOKMARKS));
     directory()->SetDownloadProgress(PREFERENCES,
                                      syncable::BuildProgress(PREFERENCES));
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Pete");
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutBaseVersion(1);
     parent.PutId(parent_id_);
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent_id_, "Pete");
     ASSERT_TRUE(child.good());
     child.PutId(child_id_);
@@ skipping 29 matching lines @@
     Entry entry(&rt, GET_BY_ID, pref_node_id);
     ASSERT_FALSE(entry.good());
   }
 }
 
 TEST_F(SyncerTest, TestPurgeWhileUnapplied) {
   // Similar to above, but for unapplied items. Bug 49278.
   {
     directory()->SetDownloadProgress(BOOKMARKS,
                                      syncable::BuildProgress(BOOKMARKS));
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Pete");
     ASSERT_TRUE(parent.good());
     parent.PutIsUnappliedUpdate(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutBaseVersion(1);
     parent.PutId(parent_id_);
   }
 
   directory()->PurgeEntriesWithTypeIn(ModelTypeSet(BOOKMARKS), ModelTypeSet(),
                                       ModelTypeSet());
 
   EXPECT_TRUE(SyncShareNudge());
   directory()->SaveChanges();
   {
     syncable::ReadTransaction rt(FROM_HERE, directory());
     Entry entry(&rt, GET_BY_ID, parent_id_);
     ASSERT_FALSE(entry.good());
   }
 }
 
 TEST_F(SyncerTest, TestPurgeWithJournal) {
   {
     directory()->SetDownloadProgress(BOOKMARKS,
                                      syncable::BuildProgress(BOOKMARKS));
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, syncable::CREATE, BOOKMARKS, wtrans.root_id(),
                         "Pete");
     ASSERT_TRUE(parent.good());
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutBaseVersion(1);
     parent.PutId(parent_id_);
     MutableEntry child(&wtrans, syncable::CREATE, BOOKMARKS, parent_id_,
                        "Pete");
     ASSERT_TRUE(child.good());
@@ skipping 29 matching lines @@
 TEST_F(SyncerTest, ResetVersions) {
   // Download some pref items.
   mock_server_->AddUpdatePref("id1", "", "tag1", 20, 20);
   mock_server_->AddUpdatePref("id2", "", "tag2", 30, 30);
   mock_server_->AddUpdatePref("id3", "", "tag3", 40, 40);
   EXPECT_TRUE(SyncShareNudge());
 
   {
     // Modify one of the preferences locally, mark another one as unapplied,
     // and create another unsynced preference.
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, GET_BY_CLIENT_TAG, "tag1");
     entry.PutIsUnsynced(true);
 
     MutableEntry entry2(&wtrans, GET_BY_CLIENT_TAG, "tag2");
     entry2.PutIsUnappliedUpdate(true);
 
     MutableEntry entry4(&wtrans, CREATE, PREFERENCES, "name");
     entry4.PutUniqueClientTag("tag4");
     entry4.PutIsUnsynced(true);
   }
 
   {
     // Reset the versions.
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     ASSERT_TRUE(directory()->ResetVersionsForType(&wtrans, PREFERENCES));
   }
 
   {
     // Verify the synced items are all with version 1 now, with
     // unsynced/unapplied state preserved.
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_CLIENT_TAG, "tag1");
     EXPECT_EQ(1, entry.GetBaseVersion());
     EXPECT_EQ(1, entry.GetServerVersion());
@@ skipping 156 matching lines @@
        {DELETED, OLD_MTIME, MOVED_FROM_ROOT}},
       CommitOrderingTest::MakeLastCommitItem(),
   };
   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());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     {
       MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "Bob");
       ASSERT_TRUE(parent.good());
       parent.PutIsUnsynced(true);
       parent.PutIsDir(true);
       parent.PutSpecifics(DefaultBookmarkSpecifics());
       parent.PutId(ids_.FromNumber(100));
       parent.PutBaseVersion(1);
       MutableEntry child(&wtrans, CREATE, BOOKMARKS, ids_.FromNumber(100),
                          "Bob");
@@ skipping 60 matching lines @@
   EXPECT_EQ(ids_.FromNumber(103), commit_ids[3]);
   EXPECT_EQ(ids_.FromNumber(104), commit_ids[4]);
   EXPECT_EQ(ids_.FromNumber(105), commit_ids[5]);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingWithNewItems) {
   syncable::Id parent1_id = ids_.MakeServer("p1");
   syncable::Id parent2_id = ids_.MakeServer("p2");
 
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "1");
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutId(parent1_id);
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "2");
     ASSERT_TRUE(child.good());
     child.PutIsUnsynced(true);
     child.PutIsDir(true);
     child.PutSpecifics(DefaultBookmarkSpecifics());
     child.PutId(parent2_id);
     parent.PutBaseVersion(1);
     child.PutBaseVersion(1);
   }
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, parent1_id, "A");
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutId(ids_.FromNumber(102));
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent1_id, "B");
     ASSERT_TRUE(child.good());
     child.PutIsUnsynced(true);
     child.PutIsDir(true);
     child.PutSpecifics(DefaultBookmarkSpecifics());
     child.PutId(ids_.FromNumber(-103));
     parent.PutBaseVersion(1);
   }
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, parent2_id, "A");
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutId(ids_.FromNumber(-104));
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent2_id, "B");
     ASSERT_TRUE(child.good());
     child.PutIsUnsynced(true);
     child.PutIsDir(true);
@@ skipping 26 matching lines @@
   EXPECT_EQ(1, count(children_begin, children_end, ids_.FromNumber(-103)));
   EXPECT_EQ(1, count(children_begin, children_end, ids_.FromNumber(102)));
   EXPECT_EQ(1, count(children_begin, children_end, ids_.FromNumber(105)));
   EXPECT_EQ(1, count(children_begin, children_end, ids_.FromNumber(-104)));
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingCounterexample) {
   syncable::Id child2_id = ids_.NewServerId();
 
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), "P");
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutId(parent_id_);
     MutableEntry child1(&wtrans, CREATE, BOOKMARKS, parent_id_, "1");
     ASSERT_TRUE(child1.good());
     child1.PutIsUnsynced(true);
     child1.PutId(child_id_);
@@ skipping 21 matching lines @@
     EXPECT_EQ(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());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(),
                         parent1_name);
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutId(parent_id_);
     parent.PutBaseVersion(1);
   }
 
   syncable::Id parent2_id = ids_.NewLocalId();
   syncable::Id child_id = ids_.NewServerId();
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent2(&wtrans, CREATE, BOOKMARKS, parent_id_, parent2_name);
     ASSERT_TRUE(parent2.good());
     parent2.PutIsUnsynced(true);
     parent2.PutIsDir(true);
     parent2.PutSpecifics(DefaultBookmarkSpecifics());
     parent2.PutId(parent2_id);
 
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent2_id, child_name);
     ASSERT_TRUE(child.good());
     child.PutIsUnsynced(true);
@@ skipping 30 matching lines @@
     EXPECT_EQ(parent2_committed_id, child.GetParentId());
   }
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingAndNewParentAndChild) {
   string parent_name = "1";
   string parent2_name = "A";
   string child_name = "B";
 
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(),
                         parent_name);
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     parent.PutId(parent_id_);
     parent.PutBaseVersion(1);
   }
 
   int64_t meta_handle_b;
   const Id parent2_local_id = ids_.NewLocalId();
   const Id child_local_id = ids_.NewLocalId();
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent2(&wtrans, CREATE, BOOKMARKS, parent_id_, parent2_name);
     ASSERT_TRUE(parent2.good());
     parent2.PutIsUnsynced(true);
     parent2.PutIsDir(true);
     parent2.PutSpecifics(DefaultBookmarkSpecifics());
 
     parent2.PutId(parent2_local_id);
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent2_local_id,
                        child_name);
     ASSERT_TRUE(child.good());
@@ skipping 52 matching lines @@
   string id = "some_id";
   string parent_id = "0";
   string name = "in_root";
   int64_t version = 10;
   int64_t timestamp = 10;
   mock_server_->AddUpdateDirectory(id, parent_id, name, version, timestamp,
                                    foreign_cache_guid(), "-1");
 
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     Entry entry(&trans, GET_BY_ID, syncable::Id::CreateFromServerId("some_id"));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.GetIsDir());
     EXPECT_EQ(version, entry.GetServerVersion());
     EXPECT_EQ(version, entry.GetBaseVersion());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetServerIsDel());
     EXPECT_FALSE(entry.GetIsDel());
   }
@@ skipping 48 matching lines @@
   // The name clash should also still be in conflict.
   EXPECT_EQ(
       3,
       GetUpdateCounters(BOOKMARKS).num_hierarchy_conflict_application_failures);
 
   // This time around, we knew that there were conflicts.
   ASSERT_TRUE(mock_server_->last_request().has_get_updates());
   VerifyHierarchyConflictsReported(mock_server_->last_request());
 
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::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.GetIsUnappliedUpdate())
         << "Duplicate name SHOULD be OK.";
 
     Entry bad_parent(&trans, GET_BY_ID, ids_.FromNumber(3));
     ASSERT_TRUE(bad_parent.good());
     EXPECT_TRUE(bad_parent.GetIsUnappliedUpdate())
         << "child of unknown parent should be in conflict";
@@ skipping 77 matching lines @@
       4,
       GetUpdateCounters(BOOKMARKS).num_hierarchy_conflict_application_failures);
 }
 
 // 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_t metahandle_folder;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(),
                        "new_folder");
     ASSERT_TRUE(entry.good());
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsUnsynced(true);
     metahandle_folder = entry.GetMetahandle();
   }
 
   // Verify it and pull the ID out of the folder.
   syncable::Id folder_id;
   int64_t metahandle_entry;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_folder);
     ASSERT_TRUE(entry.good());
     folder_id = entry.GetId();
     ASSERT_TRUE(!folder_id.ServerKnows());
   }
 
   // Create an entry in the newly created folder.
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, folder_id, "new_entry");
     ASSERT_TRUE(entry.good());
     metahandle_entry = entry.GetMetahandle();
     WriteTestDataToEntry(&trans, &entry);
   }
 
   // Verify it and pull the ID out of the entry.
   syncable::Id entry_id;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
@@ skipping 47 matching lines @@
     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_t entry_metahandle;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "new_entry");
     ASSERT_TRUE(entry.good());
     entry_metahandle = entry.GetMetahandle();
     WriteTestDataToEntry(&trans, &entry);
   }
 
   // Verify it and pull the ID out.
   syncable::Id entry_id;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
@@ skipping 32 matching lines @@
 
 // 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_t entry_metahandle;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "new_entry");
     ASSERT_TRUE(entry.good());
     entry_metahandle = entry.GetMetahandle();
     WriteTestDataToEntry(&trans, &entry);
   }
   // Verify it and pull the ID out.
   syncable::Id entry_id;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
@@ skipping 11 matching lines @@
   // Generate an update from the server with a relevant ID reassignment.
   mock_server_->AddUpdateBookmark(new_entry_id, root_id_, "new_entry",
                                   new_version, timestamp, local_cache_guid(),
                                   entry_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
   // Purposefully delete the entry now before the update application finishes.
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     Id new_entry_id =
         GetOnlyEntryWithName(&trans, trans.root_id(), "new_entry");
     MutableEntry entry(&trans, GET_BY_ID, new_entry_id);
     ASSERT_TRUE(entry.good());
     entry.PutIsDel(true);
   }
 
   // Just don't CHECK fail in sync, have the update split.
   EXPECT_TRUE(SyncShareNudge());
   {
@@ skipping 12 matching lines @@
 
 // TODO(chron): Add more unsanitized name tests.
 TEST_F(SyncerTest, ConflictMatchingEntryHandlesUnsanitizedNames) {
   mock_server_->AddUpdateDirectory(1, 0, "A/A", 10, 10, foreign_cache_guid(),
                                    "-1");
   mock_server_->AddUpdateDirectory(2, 0, "B/B", 10, 10, foreign_cache_guid(),
                                    "-2");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
 
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutIsUnappliedUpdate(true);
     A.PutServerVersion(20);
 
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.PutIsUnappliedUpdate(true);
@@ skipping 20 matching lines @@
 }
 
 TEST_F(SyncerTest, ConflictMatchingEntryHandlesNormalNames) {
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10, foreign_cache_guid(),
                                    "-1");
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10, foreign_cache_guid(),
                                    "-2");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
 
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutIsUnappliedUpdate(true);
     A.PutServerVersion(20);
 
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.PutIsUnappliedUpdate(true);
@@ skipping 34 matching lines @@
   syncable::ReadTransaction trans(FROM_HERE, directory());
 
   Id child_id = GetOnlyEntryWithName(&trans, ids_.FromNumber(4), "gggchild");
   Entry child(&trans, GET_BY_ID, child_id);
   ASSERT_TRUE(child.good());
 }
 
 class EntryCreatedInNewFolderTest : public SyncerTest {
  public:
   void CreateFolderInBob() {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry bob(
         &trans, GET_BY_ID,
         GetOnlyEntryWithName(&trans, TestIdFactory::root(), "bob"));
     ASSERT_TRUE(bob.good());
 
     MutableEntry entry2(&trans, CREATE, BOOKMARKS, bob.GetId(), "bob");
     ASSERT_TRUE(entry2.good());
     entry2.PutIsDir(true);
     entry2.PutIsUnsynced(true);
     entry2.PutSpecifics(DefaultBookmarkSpecifics());
   }
 };
 
 TEST_F(EntryCreatedInNewFolderTest, EntryCreatedInNewFolderMidSync) {
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "bob");
     ASSERT_TRUE(entry.good());
     entry.PutIsDir(true);
     entry.PutIsUnsynced(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
   }
 
   mock_server_->SetMidCommitCallback(base::Bind(
       &EntryCreatedInNewFolderTest::CreateFolderInBob, base::Unretained(this)));
   EXPECT_TRUE(SyncShareNudge());
@@ skipping 18 matching lines @@
                                   "-100");
   EXPECT_TRUE(SyncShareNudge());
   // The negative id would make us CHECK!
 }
 
 TEST_F(SyncerTest, UnappliedUpdateOnCreatedItemItemDoesNotCrash) {
   int64_t metahandle_fred;
   syncable::Id orig_id;
   {
     // Create an item.
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry fred_match(&trans, CREATE, BOOKMARKS, trans.root_id(),
                             "fred_match");
     ASSERT_TRUE(fred_match.good());
     metahandle_fred = fred_match.GetMetahandle();
     orig_id = fred_match.GetId();
     WriteTestDataToEntry(&trans, &fred_match);
   }
   // Commit it.
   EXPECT_TRUE(SyncShareNudge());
   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());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry fred_match(&trans, GET_BY_HANDLE, metahandle_fred);
     ASSERT_TRUE(fred_match.good());
     EXPECT_TRUE(fred_match.GetId().ServerKnows());
     fred_match_id = fred_match.GetId();
     mock_server_->AddUpdateBookmark(fred_match_id, trans.root_id(),
                                     "fred_match", 40, 40, local_cache_guid(),
                                     orig_id.GetServerId());
   }
   // Run the syncer.
   for (int i = 0; i < 30; ++i) {
     EXPECT_TRUE(SyncShareNudge());
   }
 }
 
 /**
  * In the event that we have a double changed entry, that is changed on both
  * the client and the server, the conflict resolver should just drop one of
  * them and accept the other.
  */
 
 TEST_F(SyncerTest, DoublyChangedWithResolver) {
   syncable::Id local_id;
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, root_id_, "Folder");
     ASSERT_TRUE(parent.good());
     parent.PutIsDir(true);
     parent.PutId(parent_id_);
     parent.PutBaseVersion(5);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent_id_, "Pete.htm");
     ASSERT_TRUE(child.good());
     local_id = child.GetId();
     child.PutId(child_id_);
@@ skipping 22 matching lines @@
   EXPECT_EQ(1u, children.size());
 }
 
 // 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);
   syncable::Id local_id;
   int64_t entry_metahandle;
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, CREATE, BOOKMARKS, root_id_, "Pete");
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetId().ServerKnows());
     local_id = entry.GetId();
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsUnsynced(true);
     entry.PutMtime(test_time);
     entry_metahandle = entry.GetMetahandle();
   }
@@ skipping 31 matching lines @@
   DisableDatatype(PREFERENCES);
   DisableDatatype(EXTENSIONS);
 
   const FullModelTypeSet all_types = FullModelTypeSet::All();
   syncable::Id parent_id = ids_.NewServerId();
   syncable::Id child_id = ids_.NewServerId();
   syncable::Id parent_local_id;
   syncable::Id child_local_id;
 
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, root_id_, "Folder");
     ASSERT_TRUE(parent.good());
     parent_local_id = parent.GetId();
     parent.PutIsDir(true);
     parent.PutIsUnsynced(true);
     parent.PutId(parent_id);
     parent.PutBaseVersion(1);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
 
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent.GetId(), "test.htm");
@@ skipping 25 matching lines @@
     directory()->GetUnappliedUpdateMetaHandles(&trans, all_types, &unapplied);
     EXPECT_EQ(0u, unapplied.size());
     Directory::Metahandles unsynced;
     directory()->GetUnsyncedMetaHandles(&trans, &unsynced);
     EXPECT_EQ(0u, unsynced.size());
   }
 }
 
 TEST_F(SyncerTest, CommittingNewDeleted) {
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "bob");
     entry.PutIsUnsynced(true);
     entry.PutIsDel(true);
   }
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(0u, mock_server_->committed_ids().size());
 }
 
 // Original problem synopsis:
 // Check failed: entry->GetBaseVersion()<= entry->GetServerVersion()
 // Client creates entry, client finishes committing entry. Between
 // commit and getting update back, we delete the entry.
 // We get the update for the entry, but the local one was modified
 // so we store the entry but don't apply it. IS_UNAPPLIED_UPDATE is set.
 // We commit deletion and get a new version number.
 // We apply unapplied updates again before we get the update about the deletion.
 // This means we have an unapplied update where server_version < base_version.
 TEST_F(SyncerTest, UnappliedUpdateDuringCommit) {
   // This test is a little fake.
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "bob");
     entry.PutId(ids_.FromNumber(20));
     entry.PutBaseVersion(1);
     entry.PutServerVersion(1);
     entry.PutServerParentId(ids_.FromNumber(9999));  // Bad parent.
     entry.PutIsUnsynced(true);
     entry.PutIsUnappliedUpdate(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutServerSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsDel(false);
   }
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(1, cycle_->status_controller().TotalNumConflictingItems());
 }
 
 // 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_t existing_metahandle;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "existing");
     ASSERT_TRUE(entry.good());
     entry.PutIsDir(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsUnsynced(true);
     existing_metahandle = entry.GetMetahandle();
   }
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry newfolder(&trans, CREATE, BOOKMARKS, trans.root_id(), "new");
     ASSERT_TRUE(newfolder.good());
     newfolder.PutIsDir(true);
     newfolder.PutSpecifics(DefaultBookmarkSpecifics());
     newfolder.PutIsUnsynced(true);
 
     MutableEntry existing(&trans, GET_BY_HANDLE, existing_metahandle);
     ASSERT_TRUE(existing.good());
     existing.PutParentId(newfolder.GetId());
     existing.PutIsUnsynced(true);
     EXPECT_TRUE(existing.GetId().ServerKnows());
 
     newfolder.PutIsDel(true);
     existing.PutIsDel(true);
   }
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(0, GetCommitCounters(BOOKMARKS).num_commits_conflict);
 }
 
 // Test conflict resolution when deleting a hierarchy of nodes within a folder
 // and running into a conflict in one of items. The conflict in a deleted
 // item must prevent all deleted ancestors from being committed as well;
 // otherwise the conflicting item would end up being orphaned.
 TEST_F(SyncerTest, DeletingFolderWithConflictInSubfolder) {
   int64_t top_handle, nested_handle, leaf_handle;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry top_entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "top");
     ASSERT_TRUE(top_entry.good());
     top_entry.PutIsDir(true);
     top_entry.PutSpecifics(DefaultBookmarkSpecifics());
     top_entry.PutIsUnsynced(true);
     top_handle = top_entry.GetMetahandle();
 
     MutableEntry nested_entry(&trans, CREATE, BOOKMARKS, top_entry.GetId(),
                               "nested");
     ASSERT_TRUE(nested_entry.good());
     nested_entry.PutIsDir(true);
     nested_entry.PutSpecifics(DefaultBookmarkSpecifics());
     nested_entry.PutIsUnsynced(true);
     nested_handle = nested_entry.GetMetahandle();
 
     MutableEntry leaf_entry(&trans, CREATE, BOOKMARKS, nested_entry.GetId(),
                             "leaf");
     ASSERT_TRUE(leaf_entry.good());
     leaf_entry.PutSpecifics(DefaultBookmarkSpecifics());
     leaf_entry.PutIsUnsynced(true);
     leaf_handle = leaf_entry.GetMetahandle();
   }
   EXPECT_TRUE(SyncShareNudge());
 
   // Delete all 3 entries and also add unapplied update to the middle one.
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry leaf_entry(&trans, GET_BY_HANDLE, leaf_handle);
     ASSERT_TRUE(leaf_entry.good());
     EXPECT_TRUE(leaf_entry.GetId().ServerKnows());
     leaf_entry.PutIsUnsynced(true);
     leaf_entry.PutIsDel(true);
 
     MutableEntry nested_entry(&trans, GET_BY_HANDLE, nested_handle);
     ASSERT_TRUE(nested_entry.good());
     EXPECT_TRUE(nested_entry.GetId().ServerKnows());
     nested_entry.PutIsUnsynced(true);
@@ skipping 31 matching lines @@
   EXPECT_THAT(mock_server_->committed_ids(),
               testing::Not(testing::Contains(top_id)));
 }
 
 // Test conflict resolution when committing a hierarchy of items and running
 // into a conflict in a parent folder. A conflicting parent must prevent any
 // of its descendants from being committed.
 TEST_F(SyncerTest, CommittingItemsWithConflictInParentFolder) {
   int64_t top_handle, nested_handle, leaf_handle;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry top_entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "top");
     ASSERT_TRUE(top_entry.good());
     top_entry.PutIsDir(true);
     top_entry.PutSpecifics(DefaultBookmarkSpecifics());
     top_entry.PutIsUnsynced(true);
     top_handle = top_entry.GetMetahandle();
 
     MutableEntry nested_entry(&trans, CREATE, BOOKMARKS, top_entry.GetId(),
                               "nested");
     ASSERT_TRUE(nested_entry.good());
     nested_entry.PutIsDir(true);
     nested_entry.PutSpecifics(DefaultBookmarkSpecifics());
     nested_entry.PutIsUnsynced(true);
     nested_handle = nested_entry.GetMetahandle();
 
     MutableEntry leaf_entry(&trans, CREATE, BOOKMARKS, nested_entry.GetId(),
                             "leaf");
     ASSERT_TRUE(leaf_entry.good());
     leaf_entry.PutSpecifics(DefaultBookmarkSpecifics());
     leaf_entry.PutIsUnsynced(true);
     leaf_handle = leaf_entry.GetMetahandle();
   }
   EXPECT_TRUE(SyncShareNudge());
 
   // Touch all 3 entries and also add unapplied update to the top one.
   syncable::Id top_id, nested_id, leaf_id;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_bookmark()->set_url("http://demo/");
 
     MutableEntry top_entry(&trans, GET_BY_HANDLE, top_handle);
     ASSERT_TRUE(top_entry.good());
     top_id = top_entry.GetId();
     EXPECT_TRUE(top_id.ServerKnows());
     top_entry.PutIsUnsynced(true);
     top_entry.PutSpecifics(specifics);
 
@@ skipping 59 matching lines @@
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     Entry pref_root(&trans, GET_TYPE_ROOT, PREFERENCES);
     ASSERT_TRUE(pref_root.good());
     pref_root_id = pref_root.GetId();
   }
 
   // Fake an item which is both unsynced and unapplied with
   // PARENT_ID set to |pref_root_id| and SERVER_PARENT_ID unset.
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, PREFERENCES, pref_root_id, "bob");
     entry.PutServerNonUniqueName("bob");
     entry.PutId(ids_.FromNumber(20));
     entry.PutBaseVersion(1);
     entry.PutServerVersion(1);
     entry.PutIsUnsynced(true);
     entry.PutIsUnappliedUpdate(true);
     entry.PutSpecifics(DefaultPreferencesSpecifics());
     entry.PutServerSpecifics(DefaultPreferencesSpecifics());
     entry.PutIsDel(false);
   }
 
   EXPECT_TRUE(SyncShareNudge());
   // Since the hierarchy isn't really changed (the type has flat hierarchy)
   // this conflict must be discarded.
   EXPECT_EQ(0, cycle_->status_controller().num_local_overwrites());
   EXPECT_EQ(0, cycle_->status_controller().num_server_overwrites());
 }
 
 TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
   int64_t newfolder_metahandle;
 
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10, foreign_cache_guid(),
                                    "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry newfolder(&trans, CREATE, BOOKMARKS, ids_.FromNumber(1),
                            "local");
     ASSERT_TRUE(newfolder.good());
     newfolder.PutIsUnsynced(true);
     newfolder.PutIsDir(true);
     newfolder.PutSpecifics(DefaultBookmarkSpecifics());
     newfolder_metahandle = newfolder.GetMetahandle();
   }
   mock_server_->AddUpdateDirectory(1, 0, "bob", 2, 20, foreign_cache_guid(),
                                    "-1");
@@ skipping 77 matching lines @@
   }
 }
 
 // Committing more than kDefaultMaxCommitBatchSize items requires that
 // we post more than one commit command to the server.  This test makes
 // sure that scenario works as expected.
 TEST_F(SyncerTest, CommitManyItemsInOneGo_Success) {
   uint32_t num_batches = 3;
   uint32_t items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     for (uint32_t i = 0; i < items_to_commit; i++) {
       string nameutf8 = base::UintToString(i);
       string name(nameutf8.begin(), nameutf8.end());
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), name);
       e.PutIsUnsynced(true);
       e.PutIsDir(true);
       e.PutSpecifics(DefaultBookmarkSpecifics());
     }
   }
   ASSERT_EQ(items_to_commit, directory()->unsynced_entity_count());
 
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(num_batches, mock_server_->commit_messages().size());
   EXPECT_EQ(0, directory()->unsynced_entity_count());
 }
 
 // Test that a single failure to contact the server will cause us to exit the
 // commit loop immediately.
 TEST_F(SyncerTest, CommitManyItemsInOneGo_PostBufferFail) {
   uint32_t num_batches = 3;
   uint32_t items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     for (uint32_t i = 0; i < items_to_commit; i++) {
       string nameutf8 = base::UintToString(i);
       string name(nameutf8.begin(), nameutf8.end());
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), name);
       e.PutIsUnsynced(true);
       e.PutIsDir(true);
       e.PutSpecifics(DefaultBookmarkSpecifics());
     }
   }
   ASSERT_EQ(items_to_commit, directory()->unsynced_entity_count());
 
   // The second commit should fail.  It will be preceded by one successful
   // GetUpdate and one succesful commit.
   mock_server_->FailNthPostBufferToPathCall(3);
   EXPECT_FALSE(SyncShareNudge());
 
   EXPECT_EQ(1U, mock_server_->commit_messages().size());
   EXPECT_EQ(SYNC_SERVER_ERROR,
             cycle_->status_controller().model_neutral_state().commit_result);
   EXPECT_EQ(items_to_commit - kDefaultMaxCommitBatchSize,
             directory()->unsynced_entity_count());
 }
 
 // Test that a single conflict response from the server will cause us to exit
 // the commit loop immediately.
 TEST_F(SyncerTest, CommitManyItemsInOneGo_CommitConflict) {
   uint32_t num_batches = 2;
   uint32_t items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     for (uint32_t i = 0; i < items_to_commit; i++) {
       string nameutf8 = base::UintToString(i);
       string name(nameutf8.begin(), nameutf8.end());
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), name);
       e.PutIsUnsynced(true);
       e.PutIsDir(true);
       e.PutSpecifics(DefaultBookmarkSpecifics());
     }
   }
   ASSERT_EQ(items_to_commit, directory()->unsynced_entity_count());
@@ skipping 155 matching lines @@
 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());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     for (int i = 0; i < item_count; i++) {
       syncable::Id next_id = ids_.NewServerId();
       syncable::Id local_id = ids_.NewLocalId();
       tree_ids.push_back(next_id);
       mock_server_->AddUpdateDirectory(next_id, last_id, "BOB", 2, 20,
                                        foreign_cache_guid(),
                                        local_id.GetServerId());
       last_id = next_id;
     }
   }
@@ skipping 26 matching lines @@
       EXPECT_FALSE(e.GetIsUnappliedUpdate());
     }
   }
 }
 
 TEST_F(SyncerTest, DontCrashOnCaseChange) {
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10, foreign_cache_guid(),
                                    "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry e(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(e.good());
     e.PutIsUnsynced(true);
   }
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(1, 0, "BOB", 2, 20, foreign_cache_guid(),
                                    "-1");
   EXPECT_FALSE(SyncShareNudge());  // USED TO CAUSE AN ASSERT
 }
 
 TEST_F(SyncerTest, UnsyncedItemAndUpdate) {
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10, foreign_cache_guid(),
                                    "-1");
   EXPECT_TRUE(SyncShareNudge());
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(2, 0, "bob", 2, 20, foreign_cache_guid(),
                                    "-2");
   EXPECT_TRUE(SyncShareNudge());  // USED TO CAUSE AN ASSERT
 }
 
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath) {
   mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10, foreign_cache_guid(),
                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   int64_t local_folder_handle;
   syncable::Id local_folder_id;
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry new_entry(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(),
                            "Bar.htm");
     ASSERT_TRUE(new_entry.good());
     local_folder_id = new_entry.GetId();
     local_folder_handle = new_entry.GetMetahandle();
     new_entry.PutIsUnsynced(true);
     new_entry.PutSpecifics(DefaultBookmarkSpecifics());
     MutableEntry old(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(old.good());
     WriteTestDataToEntry(&wtrans, &old);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 20, 20, foreign_cache_guid(),
                                   "-1");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_FALSE(SyncShareNudge());
   {
     // Update #20 should have been dropped in favor of the local version.
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::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_NE(local.GetMetahandle(), server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_TRUE(server.GetIsUnsynced());
     EXPECT_TRUE(local.GetIsUnsynced());
     EXPECT_EQ("Foo.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
   }
   // Allow local changes to commit.
   mock_server_->set_conflict_all_commits(false);
   EXPECT_TRUE(SyncShareNudge());
 
   // Now add a server change to make the two names equal.  There should
   // be no conflict with that, since names are not unique.
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 30, 30, foreign_cache_guid(),
                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::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_NE(local.GetMetahandle(), server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_FALSE(server.GetIsUnsynced());
     EXPECT_FALSE(local.GetIsUnsynced());
     EXPECT_EQ("Bar.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
     EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
               server.GetSpecifics().bookmark().url());
   }
 }
 
 // Same as NewEntryAnddServerEntrySharePath, but using the old-style protocol.
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath_OldBookmarksProto) {
   mock_server_->set_use_legacy_bookmarks_protocol(true);
   mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10, foreign_cache_guid(),
                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   int64_t local_folder_handle;
   syncable::Id local_folder_id;
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry new_entry(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(),
                            "Bar.htm");
     ASSERT_TRUE(new_entry.good());
     local_folder_id = new_entry.GetId();
     local_folder_handle = new_entry.GetMetahandle();
     new_entry.PutIsUnsynced(true);
     new_entry.PutSpecifics(DefaultBookmarkSpecifics());
     MutableEntry old(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(old.good());
     WriteTestDataToEntry(&wtrans, &old);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 20, 20, foreign_cache_guid(),
                                   "-1");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_FALSE(SyncShareNudge());
   {
     // Update #20 should have been dropped in favor of the local version.
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::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_NE(local.GetMetahandle(), server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_TRUE(server.GetIsUnsynced());
     EXPECT_TRUE(local.GetIsUnsynced());
     EXPECT_EQ("Foo.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
   }
   // Allow local changes to commit.
   mock_server_->set_conflict_all_commits(false);
   EXPECT_TRUE(SyncShareNudge());
 
   // Now add a server change to make the two names equal.  There should
   // be no conflict with that, since names are not unique.
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 30, 30, foreign_cache_guid(),
                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::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_NE(local.GetMetahandle(), server.GetMetahandle());
     EXPECT_FALSE(server.GetIsUnappliedUpdate());
     EXPECT_FALSE(local.GetIsUnappliedUpdate());
     EXPECT_FALSE(server.GetIsUnsynced());
     EXPECT_FALSE(local.GetIsUnsynced());
     EXPECT_EQ("Bar.htm", server.GetNonUniqueName());
     EXPECT_EQ("Bar.htm", local.GetNonUniqueName());
     EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
               server.GetSpecifics().bookmark().url());
   }
 }
 
 // Circular links should be resolved by the server.
 TEST_F(SyncerTest, SiblingDirectoriesBecomeCircular) {
   // we don't currently resolve this. This test ensures we don't.
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10, foreign_cache_guid(),
                                    "-1");
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10, foreign_cache_guid(),
                                    "-2");
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     A.PutParentId(ids_.FromNumber(2));
     A.PutNonUniqueName("B");
   }
   mock_server_->AddUpdateDirectory(2, 1, "A", 20, 20, foreign_cache_guid(),
                                    "-2");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_FALSE(SyncShareNudge());
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::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_EQ("B", A.GetNonUniqueName());
     EXPECT_EQ("B", B.GetNonUniqueName());
   }
 }
 
 TEST_F(SyncerTest, SwapEntryNames) {
   // Simple transaction test.
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10, foreign_cache_guid(),
                                    "-1");
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10, foreign_cache_guid(),
                                    "-2");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.PutIsUnsynced(true);
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.PutIsUnsynced(true);
     A.PutNonUniqueName("C");
     B.PutNonUniqueName("A");
     A.PutNonUniqueName("B");
   }
   EXPECT_FALSE(SyncShareNudge());
 }
 
 TEST_F(SyncerTest, DualDeletionWithNewItemNameClash) {
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10, foreign_cache_guid(),
                                    "-1");
   mock_server_->AddUpdateBookmark(2, 0, "B", 10, 10, foreign_cache_guid(),
                                   "-2");
   mock_server_->set_conflict_all_commits(true);
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     WriteTestDataToEntry(&trans, &B);
     B.PutIsDel(true);
   }
   mock_server_->AddUpdateBookmark(2, 0, "A", 11, 11, foreign_cache_guid(),
                                   "-2");
   mock_server_->SetLastUpdateDeleted();
   EXPECT_TRUE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_FALSE(B.GetIsUnsynced());
     EXPECT_FALSE(B.GetIsUnappliedUpdate());
   }
 }
 
 // When we undelete an entity as a result of conflict resolution, we reuse the
 // existing server id and preserve the old version, simply updating the server
 // version with the new non-deleted entity.
 TEST_F(SyncerTest, ResolveWeWroteTheyDeleted) {
   int64_t bob_metahandle;
 
   mock_server_->AddUpdateBookmark(1, 0, "bob", 1, 10, foreign_cache_guid(),
                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob_metahandle = bob.GetMetahandle();
     WriteTestDataToEntry(&trans, &bob);
   }
   mock_server_->AddUpdateBookmark(1, 0, "bob", 2, 10, foreign_cache_guid(),
                                   "-1");
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   EXPECT_FALSE(SyncShareNudge());
   EXPECT_FALSE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry bob(&trans, GET_BY_HANDLE, bob_metahandle);
     ASSERT_TRUE(bob.good());
     EXPECT_TRUE(bob.GetIsUnsynced());
     EXPECT_TRUE(bob.GetId().ServerKnows());
     EXPECT_FALSE(bob.GetIsUnappliedUpdate());
     EXPECT_FALSE(bob.GetIsDel());
     EXPECT_EQ(2, bob.GetServerVersion());
     EXPECT_EQ(2, bob.GetBaseVersion());
   }
 }
 
 // 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());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry folder(&trans, CREATE, BOOKMARKS, trans.root_id(), "bob");
     ASSERT_TRUE(folder.good());
     folder.PutIsUnsynced(true);
     folder.PutIsDir(true);
     folder.PutSpecifics(DefaultBookmarkSpecifics());
     MutableEntry folder2(&trans, CREATE, BOOKMARKS, trans.root_id(), "fred");
     ASSERT_TRUE(folder2.good());
     folder2.PutIsUnsynced(false);
     folder2.PutIsDir(true);
     folder2.PutSpecifics(DefaultBookmarkSpecifics());
     folder2.PutBaseVersion(3);
     folder2.PutId(syncable::Id::CreateFromServerId("mock_server:10000"));
   }
   mock_server_->set_next_new_id(10000);
   EXPECT_EQ(1u, directory()->unsynced_entity_count());
   // we get back a bad id in here (should never happen).
   EXPECT_FALSE(SyncShareNudge());
   EXPECT_EQ(1u, directory()->unsynced_entity_count());
   EXPECT_TRUE(SyncShareNudge());  // another bad id in here.
   EXPECT_EQ(0u, directory()->unsynced_entity_count());
 }
 
 TEST_F(SyncerTest, DeletedEntryWithBadParentInLoopCalculation) {
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10, foreign_cache_guid(),
                                    "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     // This is valid, because the parent could have gone away a long time ago.
     bob.PutParentId(ids_.FromNumber(54));
     bob.PutIsDel(true);
     bob.PutIsUnsynced(true);
   }
   mock_server_->AddUpdateDirectory(2, 1, "fred", 1, 10, foreign_cache_guid(),
                                    "-2");
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_TRUE(SyncShareNudge());
 }
 
 TEST_F(SyncerTest, ConflictResolverMergesLocalDeleteAndServerUpdate) {
   syncable::Id local_id;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 
     MutableEntry local_deleted(&trans, CREATE, BOOKMARKS, trans.root_id(),
                                "name");
     local_id = local_deleted.GetId();
     local_deleted.PutId(ids_.FromNumber(1));
     local_deleted.PutBaseVersion(1);
     local_deleted.PutIsDel(true);
     local_deleted.PutIsDir(false);
     local_deleted.PutIsUnsynced(true);
     local_deleted.PutSpecifics(DefaultBookmarkSpecifics());
@@ skipping 19 matching lines @@
 
 // This ensures that for extensions, we resolve the conflict of local updates
 // and server deletes in favor of the server, to prevent extensions from
 // being reinstalled after uninstall.
 TEST_F(SyncerTest, ConflictResolverAcceptsServerDeleteForExtensions) {
   ASSERT_TRUE(context_->GetEnabledTypes().Has(EXTENSIONS));
 
   // Create an extension entry.
   int64_t metahandle;
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry extension(&trans, CREATE, EXTENSIONS, trans.root_id(),
                            "extension_name");
     ASSERT_TRUE(extension.good());
     sync_pb::EntitySpecifics specifics;
     AddDefaultFieldValue(EXTENSIONS, &specifics);
     extension.PutSpecifics(specifics);
     EXPECT_FALSE(extension.GetIsUnappliedUpdate());
     EXPECT_FALSE(extension.GetId().ServerKnows());
     metahandle = extension.GetMetahandle();
     extension.PutIsUnsynced(true);
@@ skipping 19 matching lines @@
   // Simulate another client deleting the item.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle);
     mock_server_->AddUpdateTombstone(id, EXTENSIONS);
   }
 
   // Create a local update, which should cause a conflict with the delete that
   // we just pushed to the server.
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry extension(&trans, GET_BY_HANDLE, metahandle);
     ASSERT_TRUE(extension.good());
     sync_pb::EntitySpecifics specifics;
     AddDefaultFieldValue(EXTENSIONS, &specifics);
     specifics.mutable_extension()->set_disable_reasons(2);
     extension.PutSpecifics(specifics);
     EXPECT_FALSE(extension.GetIsUnappliedUpdate());
     extension.PutIsUnsynced(true);
   }
 
@@ skipping 10 matching lines @@
     EXPECT_GE(entry.GetBaseVersion(), 0);
     EXPECT_GE(entry.GetServerVersion(), 0);
   }
 }
 
 // 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());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
 
     MutableEntry local_deleted(&trans, CREATE, BOOKMARKS, trans.root_id(),
                                "name");
     local_deleted.PutId(ids_.FromNumber(1));
     local_deleted.PutBaseVersion(1);
     local_deleted.PutIsDel(true);
     local_deleted.PutIsDir(true);
     local_deleted.PutIsUnsynced(true);
     local_deleted.PutSpecifics(DefaultBookmarkSpecifics());
   }
@@ skipping 22 matching lines @@
 
 // Bug Synopsis:
 // Merge conflict resolution will merge a new local entry with another entry
 // that needs updates, resulting in CHECK.
 TEST_F(SyncerTest, MergingExistingItems) {
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10, local_cache_guid(),
                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(),
                        "Copy of base");
     WriteTestDataToEntry(&trans, &entry);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50,
                                   local_cache_guid(), "-1");
   EXPECT_FALSE(SyncShareNudge());
 }
 
 // In this test a long changelog contains a child at the start of the changelog
@@ skipping 51 matching lines @@
 }
 
 TEST_F(SyncerTest, DontMergeTwoExistingItems) {
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10, foreign_cache_guid(),
                                   "-1");
   mock_server_->AddUpdateBookmark(2, 0, "base2", 10, 10, foreign_cache_guid(),
                                   "-2");
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     entry.PutNonUniqueName("Copy of base");
     entry.PutIsUnsynced(true);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50,
                                   foreign_cache_guid(), "-1");
   EXPECT_FALSE(SyncShareNudge());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
@@ skipping 49 matching lines @@
   }
 }
 
 TEST_F(SyncerTest, TestMoveSanitizedNamedFolder) {
   mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1, foreign_cache_guid(),
                                    "-1");
   mock_server_->AddUpdateDirectory(2, 0, ":::", 1, 2, foreign_cache_guid(),
                                    "-2");
   EXPECT_TRUE(SyncShareNudge());
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     entry.PutParentId(ids_.FromNumber(1));
     EXPECT_TRUE(entry.PutIsUnsynced(true));
   }
   EXPECT_TRUE(SyncShareNudge());
   // We use the same sync ts as before so our times match up.
   mock_server_->AddUpdateDirectory(2, 1, ":::", 2, 2, foreign_cache_guid(),
                                    "-2");
   EXPECT_TRUE(SyncShareNudge());
@@ skipping 41 matching lines @@
     EXPECT_EQ(in_root_id, in_in_root.GetParentId());
   }
 }
 
 TEST_F(SyncerTest, DirectoryCommitTest) {
   syncable::Id in_root_id, in_dir_id;
   int64_t foo_metahandle;
   int64_t bar_metahandle;
 
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, root_id_, "foo");
     ASSERT_TRUE(parent.good());
     parent.PutIsUnsynced(true);
     parent.PutIsDir(true);
     parent.PutSpecifics(DefaultBookmarkSpecifics());
     in_root_id = parent.GetId();
     foo_metahandle = parent.GetMetahandle();
 
     MutableEntry child(&wtrans, CREATE, BOOKMARKS, parent.GetId(), "bar");
     ASSERT_TRUE(child.good());
@@ skipping 116 matching lines @@
 
   mock_server_->AddUpdateDirectory(folder_one_id, TestIdFactory::root(),
                                    "folder_one", 1, 1, foreign_cache_guid(),
                                    "-1");
   mock_server_->AddUpdateDirectory(folder_two_id, TestIdFactory::root(),
                                    "folder_two", 1, 1, foreign_cache_guid(),
                                    "-2");
   EXPECT_TRUE(SyncShareNudge());
   {
     // A moved entry should send an "old parent."
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_ID, folder_one_id);
     ASSERT_TRUE(entry.good());
     entry.PutParentId(folder_two_id);
     entry.PutIsUnsynced(true);
     // A new entry should send no "old parent."
     MutableEntry create(&trans, CREATE, BOOKMARKS, trans.root_id(),
                         "new_folder");
     create.PutIsUnsynced(true);
     create.PutSpecifics(DefaultBookmarkSpecifics());
   }
   EXPECT_TRUE(SyncShareNudge());
   const sync_pb::CommitMessage& commit = mock_server_->last_sent_commit();
   ASSERT_EQ(2, commit.entries_size());
   EXPECT_EQ("2", commit.entries(0).parent_id_string());
   EXPECT_EQ("0", commit.entries(0).old_parent_id());
   EXPECT_FALSE(commit.entries(1).has_old_parent_id());
 }
 
 TEST_F(SyncerTest, Test64BitVersionSupport) {
   int64_t really_big_int = std::numeric_limits<int64_t>::max() - 12;
   const string name("ringo's dang orang ran rings around my o-ring");
   int64_t item_metahandle;
 
   // Try writing max int64_t to the version fields of a meta entry.
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(), name);
     ASSERT_TRUE(entry.good());
     entry.PutBaseVersion(really_big_int);
     entry.PutServerVersion(really_big_int);
     entry.PutId(ids_.NewServerId());
     item_metahandle = entry.GetMetahandle();
   }
   // Now read it back out and make sure the value is max int64_t.
   syncable::ReadTransaction rtrans(FROM_HERE, directory());
   Entry entry(&rtrans, GET_BY_HANDLE, item_metahandle);
   ASSERT_TRUE(entry.good());
   EXPECT_EQ(really_big_int, entry.GetBaseVersion());
 }
 
 TEST_F(SyncerTest, TestSimpleUndelete) {
   Id id = ids_.MakeServer("undeletion item"), root = TestIdFactory::root();
   mock_server_->set_conflict_all_commits(true);
   // Let there be an entry from the server.
   mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10, foreign_cache_guid(),
                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   // Check it out and delete it.
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsDel());
     // Delete it locally.
     entry.PutIsDel(true);
   }
   EXPECT_TRUE(SyncShareNudge());
   // Confirm we see IS_DEL and not SERVER_IS_DEL.
@@ skipping 40 matching lines @@
 
 TEST_F(SyncerTest, TestUndeleteWithMissingDeleteUpdate) {
   Id id = ids_.MakeServer("undeletion item"), root = TestIdFactory::root();
   // Let there be a entry, from the server.
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10, foreign_cache_guid(),
                                   "-1");
   EXPECT_TRUE(SyncShareNudge());
   // Check it out and delete it.
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&wtrans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsDel());
     // Delete it locally.
     entry.PutIsDel(true);
   }
   EXPECT_TRUE(SyncShareNudge());
   // Confirm we see IS_DEL and not SERVER_IS_DEL.
@@ skipping 112 matching lines @@
     EXPECT_FALSE(perm_folder.GetIsUnappliedUpdate());
     EXPECT_FALSE(perm_folder.GetIsUnsynced());
     EXPECT_EQ("permitem1", perm_folder.GetNonUniqueName());
   }
 }
 
 TEST_F(SyncerTest, ClientTagUncommittedTagMatchesUpdate) {
   int64_t original_metahandle = 0;
 
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry pref(&trans, CREATE, PREFERENCES, ids_.root(), "name");
     ASSERT_TRUE(pref.good());
     pref.PutUniqueClientTag("tag");
     pref.PutIsUnsynced(true);
     EXPECT_FALSE(pref.GetIsUnappliedUpdate());
     EXPECT_FALSE(pref.GetId().ServerKnows());
     original_metahandle = pref.GetMetahandle();
   }
 
   syncable::Id server_id = TestIdFactory::MakeServer("id");
@@ skipping 36 matching lines @@
     // metahandle; client should have won the conflict resolution.
     EXPECT_EQ(original_metahandle, pref.GetMetahandle());
     EXPECT_EQ("tag", pref.GetUniqueClientTag());
     EXPECT_TRUE(pref.GetId().ServerKnows());
   }
 }
 
 TEST_F(SyncerTest, ClientTagConflictWithDeletedLocalEntry) {
   {
     // Create a deleted local entry with a unique client tag.
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry pref(&trans, CREATE, PREFERENCES, ids_.root(), "name");
     ASSERT_TRUE(pref.good());
     ASSERT_FALSE(pref.GetId().ServerKnows());
     pref.PutUniqueClientTag("tag");
     pref.PutIsUnsynced(true);
 
     // Note: IS_DEL && !ServerKnows() will clear the UNSYNCED bit.
     // (We never attempt to commit server-unknown deleted items, so this
     // helps us clean up those entries).
     pref.PutIsDel(true);
@@ skipping 220 matching lines @@
 
     ASSERT_TRUE(directory()->InitialSyncEndedForType(&trans, PREFERENCES));
 
     Entry pref_root(&trans, GET_TYPE_ROOT, PREFERENCES);
     ASSERT_TRUE(pref_root.good());
     pref_root_id = pref_root.GetId();
   }
 
   // Add a preference item with explicit parent ID.
   {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, PREFERENCES, pref_root_id, "tag");
     ASSERT_TRUE(entry.good());
     entry.PutIsDir(false);
     entry.PutBaseVersion(1);
     entry.PutUniqueClientTag("tag");
     entry.PutId(ids_.FromNumber(2));
   }
 
   // Verify the entry above.
   {
@@ skipping 287 matching lines @@
 }
 
 // Tests specifically related to bookmark (and therefore no client tags) sync
 // logic. Entities without client tags have custom logic in parts of the code,
 // and hence are not covered by e.g. the Undeletion tests below.
 class SyncerBookmarksTest : public SyncerTest {
  public:
   SyncerBookmarksTest() : metahandle_(syncable::kInvalidMetaHandle) {}
 
   void Create() {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry bookmark(&trans, CREATE, BOOKMARKS, ids_.root(), "clientname");
     ASSERT_TRUE(bookmark.good());
     bookmark.PutSpecifics(DefaultBookmarkSpecifics());
     EXPECT_FALSE(bookmark.GetIsUnappliedUpdate());
     EXPECT_FALSE(bookmark.GetId().ServerKnows());
     metahandle_ = bookmark.GetMetahandle();
     local_id_ = bookmark.GetId();
     bookmark.PutIsUnsynced(true);
   }
 
   void Update() {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry bookmark(&trans, GET_BY_ID, local_id_);
     ASSERT_TRUE(bookmark.good());
     bookmark.PutSpecifics(DefaultBookmarkSpecifics());
     EXPECT_FALSE(bookmark.GetIsUnappliedUpdate());
     bookmark.PutIsUnsynced(true);
     if (bookmark.GetSyncing())
       bookmark.PutDirtySync(true);
   }
 
   void Delete() {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_HANDLE, metahandle_);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(metahandle_, entry.GetMetahandle());
     // The order of setting IS_UNSYNCED vs IS_DEL matters. See
     // WriteNode::Tombstone().
     entry.PutIsUnsynced(true);
     if (entry.GetSyncing())
       entry.PutDirtySync(true);
     entry.PutIsDel(true);
   }
 
   void UpdateAndDelete() {
     Update();
     Delete();
   }
 
   void Undelete() {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_HANDLE, metahandle_);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(metahandle_, entry.GetMetahandle());
     EXPECT_TRUE(entry.GetIsDel());
     entry.PutIsDel(false);
     entry.PutIsUnsynced(true);
     if (entry.GetSyncing())
       entry.PutDirtySync(true);
   }
 
@@ skipping 195 matching lines @@
 //     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());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry perm_folder(&trans, CREATE, PREFERENCES, ids_.root(),
                              "clientname");
     ASSERT_TRUE(perm_folder.good());
     perm_folder.PutUniqueClientTag(client_tag_);
     perm_folder.PutIsUnsynced(true);
     if (perm_folder.GetSyncing())
       perm_folder.PutDirtySync(true);
     perm_folder.PutSpecifics(DefaultPreferencesSpecifics());
     EXPECT_FALSE(perm_folder.GetIsUnappliedUpdate());
     EXPECT_FALSE(perm_folder.GetId().ServerKnows());
     metahandle_ = perm_folder.GetMetahandle();
     local_id_ = perm_folder.GetId();
   }
 
   void Delete() {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_CLIENT_TAG, client_tag_);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(metahandle_, entry.GetMetahandle());
     // The order of setting IS_UNSYNCED vs IS_DEL matters. See
     // WriteNode::Tombstone().
     entry.PutIsUnsynced(true);
     if (entry.GetSyncing())
       entry.PutDirtySync(true);
     entry.PutIsDel(true);
   }
 
   void Undelete() {
-    WriteTransaction trans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_CLIENT_TAG, client_tag_);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(metahandle_, entry.GetMetahandle());
     EXPECT_TRUE(entry.GetIsDel());
     entry.PutIsDel(false);
     entry.PutIsUnsynced(true);
     if (entry.GetSyncing())
       entry.PutDirtySync(true);
   }
 
@@ skipping 465 matching lines @@
     return (GetParam() & (1 << TEST_PARAM_AUTOFILL_ENABLE_BIT)) == 0;
   }
 };
 
 INSTANTIATE_TEST_CASE_P(ExtensionsActivity,
                         MixedResult,
                         testing::Range(0, 1 << TEST_PARAM_BIT_COUNT));
 
 TEST_P(MixedResult, ExtensionsActivity) {
   {
-    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    syncable::WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
 
     MutableEntry pref(&wtrans, CREATE, PREFERENCES, wtrans.root_id(), "pref");
     ASSERT_TRUE(pref.good());
     pref.PutIsUnsynced(true);
 
     MutableEntry bookmark(&wtrans, CREATE, BOOKMARKS, wtrans.root_id(),
                           "bookmark");
     ASSERT_TRUE(bookmark.good());
     bookmark.PutIsUnsynced(true);
 
@@ skipping 28 matching lines @@
     EXPECT_EQ("xyz", final_monitor_records["xyz"].extension_id);
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U, final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 }  // namespace syncer