[Sync] Split DirectoryChangeListener for thread-safety

chrome/browser/sync/engine/syncer_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
+#include "base/tracked.h"
 #include "build/build_config.h"
 #include "chrome/browser/sync/engine/conflict_resolver.h"
 #include "chrome/browser/sync/engine/get_commit_ids_command.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/process_updates_command.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_proto_util.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/engine/syncproto.h"
@@ skipping 160 matching lines @@
     listeners.push_back(this);
     context_.reset(new SyncSessionContext(mock_server_.get(),
         syncdb_.manager(), this, listeners));
     context_->set_account_name(syncdb_.name());
     ASSERT_FALSE(context_->resolver());
     syncer_ = new Syncer();
     session_.reset(MakeSession());
 
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     CHECK(dir.good());
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     syncable::Directory::ChildHandles children;
     dir->GetChildHandlesById(&trans, trans.root_id(), &children);
     ASSERT_TRUE(0 == children.size());
     saw_syncer_event_ = false;
     root_id_ = TestIdFactory::root();
     parent_id_ = ids_.MakeServer("parent id");
     child_id_ = ids_.MakeServer("child id");
   }
 
   virtual void TearDown() {
@@ skipping 64 matching lines @@
 
     static const CommitOrderingTest LAST_COMMIT_ITEM;
   };
 
   void RunCommitOrderingTest(CommitOrderingTest* test) {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     ASSERT_TRUE(dir.good());
 
     map<int, syncable::Id> expected_positions;
     {  // Transaction scope.
-      WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+      WriteTransaction trans(dir, UNITTEST, FROM_HERE);
       while (!test->id.IsRoot()) {
         if (test->commit_index >= 0) {
           map<int, syncable::Id>::value_type entry(test->commit_index,
                                                    test->id);
           bool double_position = !expected_positions.insert(entry).second;
           ASSERT_FALSE(double_position) << "Two id's expected at one position";
         }
         string utf8_name = test->id.GetServerId();
         string name(utf8_name.begin(), utf8_name.end());
         MutableEntry entry(&trans, CREATE, test->parent_id, name);
@@ skipping 45 matching lines @@
       EXPECT_TRUE(expected_positions[i] == mock_server_->committed_ids()[i]);
     }
   }
 
   void DoTruncationTest(const ScopedDirLookup& dir,
                         const vector<int64>& unsynced_handle_view,
                         const vector<syncable::Id>& expected_id_order) {
     // The expected order is "x", "b", "c", "e", truncated appropriately.
     for (size_t limit = expected_id_order.size() + 2; limit > 0; --limit) {
       StatusController* status = session_->status_controller();
-      WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+      WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
       ScopedSetSessionWriteTransaction set_trans(session_.get(), &wtrans);
       status->set_unsynced_handles(unsynced_handle_view);
 
       ModelSafeRoutingInfo routes;
       GetModelSafeRoutingInfo(&routes);
       GetCommitIdsCommand command(limit);
       command.BuildCommitIds(session_->status_controller()->unsynced_handles(),
           session_->write_transaction(), routes);
       vector<syncable::Id> output =
           command.ordered_commit_set_->GetAllCommitIds();
@@ skipping 20 matching lines @@
   int64 CreateUnsyncedDirectory(const string& entry_name,
       const string& idstring) {
     return CreateUnsyncedDirectory(entry_name,
         syncable::Id::CreateFromServerId(idstring));
   }
 
   int64 CreateUnsyncedDirectory(const string& entry_name,
       const syncable::Id& id) {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     EXPECT_TRUE(dir.good());
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&wtrans, syncable::CREATE, wtrans.root_id(),
                        entry_name);
     EXPECT_TRUE(entry.good());
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::IS_DIR, true);
     entry.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(syncable::BASE_VERSION, id.ServerKnows() ? 1 : 0);
     entry.Put(syncable::ID, id);
     return entry.Get(META_HANDLE);
   }
 
   void EnableDatatype(syncable::ModelType model_type) {
     enabled_datatypes_[model_type] = true;
     mock_server_->ExpectGetUpdatesRequestTypes(enabled_datatypes_);
   }
 
   void DisableDatatype(syncable::ModelType model_type) {
     enabled_datatypes_[model_type] = false;
     mock_server_->ExpectGetUpdatesRequestTypes(enabled_datatypes_);
   }
 
   template<typename FieldType, typename ValueType>
   ValueType GetField(int64 metahandle, FieldType field,
       ValueType default_value) const {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     EXPECT_TRUE(dir.good());
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_HANDLE, metahandle);
     EXPECT_TRUE(entry.good());
     if (!entry.good()) {
       return default_value;
     }
     EXPECT_EQ(metahandle, entry.Get(META_HANDLE));
     return entry.Get(field);
   }
 
   // Helper getters that work without a transaction, to reduce boilerplate.
@@ skipping 52 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SyncerTest);
 };
 
 TEST_F(SyncerTest, TestCallGatherUnsyncedEntries) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   {
     Syncer::UnsyncedMetaHandles handles;
     {
-      ReadTransaction trans(dir, __FILE__, __LINE__);
+      ReadTransaction trans(dir, FROM_HERE);
       SyncerUtil::GetUnsyncedEntries(&trans, &handles);
     }
     ASSERT_TRUE(0 == handles.size());
   }
   // TODO(sync): When we can dynamically connect and disconnect the mock
   // ServerConnectionManager test disconnected GetUnsyncedEntries here. It's a
   // regression for a very old bug.
 }
 
 TEST_F(SyncerTest, GetCommitIdsCommandTruncates) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   int64 handle_c = CreateUnsyncedDirectory("C", ids_.MakeLocal("c"));
   int64 handle_x = CreateUnsyncedDirectory("X", ids_.MakeLocal("x"));
   int64 handle_b = CreateUnsyncedDirectory("B", ids_.MakeLocal("b"));
   int64 handle_d = CreateUnsyncedDirectory("D", ids_.MakeLocal("d"));
   int64 handle_e = CreateUnsyncedDirectory("E", ids_.MakeLocal("e"));
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry_x(&wtrans, GET_BY_HANDLE, handle_x);
     MutableEntry entry_b(&wtrans, GET_BY_HANDLE, handle_b);
     MutableEntry entry_c(&wtrans, GET_BY_HANDLE, handle_c);
     MutableEntry entry_d(&wtrans, GET_BY_HANDLE, handle_d);
     MutableEntry entry_e(&wtrans, GET_BY_HANDLE, handle_e);
     entry_x.Put(SPECIFICS, DefaultBookmarkSpecifics());
     entry_b.Put(SPECIFICS, DefaultBookmarkSpecifics());
     entry_c.Put(SPECIFICS, DefaultBookmarkSpecifics());
     entry_d.Put(SPECIFICS, DefaultBookmarkSpecifics());
     entry_e.Put(SPECIFICS, DefaultBookmarkSpecifics());
@@ skipping 17 matching lines @@
 }
 
 // TODO(chron): More corner case unit tests around validation.
 TEST_F(SyncerTest, TestCommitMetahandleIterator) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   StatusController* status = session_->status_controller();
   const vector<int64>& unsynced(status->unsynced_handles());
 
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     ScopedSetSessionWriteTransaction set_trans(session_.get(), &wtrans);
 
     sessions::OrderedCommitSet commit_set(session_->routing_info());
     GetCommitIdsCommand::CommitMetahandleIterator iterator(unsynced, &wtrans,
         &commit_set);
     EXPECT_FALSE(iterator.Valid());
     EXPECT_FALSE(iterator.Increment());
   }
 
   {
     vector<int64> session_metahandles;
     session_metahandles.push_back(CreateUnsyncedDirectory("test1", "testid1"));
     session_metahandles.push_back(CreateUnsyncedDirectory("test2", "testid2"));
     session_metahandles.push_back(CreateUnsyncedDirectory("test3", "testid3"));
     status->set_unsynced_handles(session_metahandles);
 
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     ScopedSetSessionWriteTransaction set_trans(session_.get(), &wtrans);
     sessions::OrderedCommitSet commit_set(session_->routing_info());
     GetCommitIdsCommand::CommitMetahandleIterator iterator(unsynced, &wtrans,
         &commit_set);
 
     EXPECT_TRUE(iterator.Valid());
     EXPECT_TRUE(iterator.Current() == session_metahandles[0]);
     EXPECT_TRUE(iterator.Increment());
 
     EXPECT_TRUE(iterator.Valid());
     EXPECT_TRUE(iterator.Current() == session_metahandles[1]);
     EXPECT_TRUE(iterator.Increment());
 
     EXPECT_TRUE(iterator.Valid());
     EXPECT_TRUE(iterator.Current() == session_metahandles[2]);
     EXPECT_FALSE(iterator.Increment());
 
     EXPECT_FALSE(iterator.Valid());
   }
 }
 
 TEST_F(SyncerTest, TestGetUnsyncedAndSimpleCommit) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(),
                         "Pete");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNSYNCED, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::BASE_VERSION, 1);
     parent.Put(syncable::ID, parent_id_);
     MutableEntry child(&wtrans, syncable::CREATE, parent_id_, "Pete");
     ASSERT_TRUE(child.good());
     child.Put(syncable::ID, child_id_);
     child.Put(syncable::BASE_VERSION, 1);
     WriteTestDataToEntry(&wtrans, &child);
   }
 
   StatusController* status = session_->status_controller();
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   EXPECT_TRUE(2 == status->unsynced_handles().size());
   ASSERT_TRUE(2 == mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   {
-    ReadTransaction rt(dir, __FILE__, __LINE__);
+    ReadTransaction rt(dir, FROM_HERE);
     Entry entry(&rt, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(entry.good());
     VerifyTestDataInEntry(&rt, &entry);
   }
 }
 
 TEST_F(SyncerTest, TestPurgeWhileUnsynced) {
   // Similar to above, but throw a purge operation into the mix. Bug 49278.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   syncable::Id pref_node_id = TestIdFactory::MakeServer("Tim");
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(), "Pete");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNSYNCED, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::BASE_VERSION, 1);
     parent.Put(syncable::ID, parent_id_);
     MutableEntry child(&wtrans, syncable::CREATE, parent_id_, "Pete");
     ASSERT_TRUE(child.good());
     child.Put(syncable::ID, child_id_);
@@ skipping 14 matching lines @@
   dir->PurgeEntriesWithTypeIn(types_to_purge);
 
   StatusController* status = session_->status_controller();
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   EXPECT_EQ(2U, status->unsynced_handles().size());
   ASSERT_EQ(2U, mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(child_id_ == mock_server_->committed_ids()[1]);
   {
-    ReadTransaction rt(dir, __FILE__, __LINE__);
+    ReadTransaction rt(dir, FROM_HERE);
     Entry entry(&rt, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(entry.good());
     VerifyTestDataInEntry(&rt, &entry);
   }
   dir->SaveChanges();
   {
-    ReadTransaction rt(dir, __FILE__, __LINE__);
+    ReadTransaction rt(dir, FROM_HERE);
     Entry entry(&rt, syncable::GET_BY_ID, pref_node_id);
     ASSERT_FALSE(entry.good());
   }
 }
 
 TEST_F(SyncerTest, TestPurgeWhileUnapplied) {
   // Similar to above, but for unapplied items. Bug 49278.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(), "Pete");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNAPPLIED_UPDATE, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::BASE_VERSION, 1);
     parent.Put(syncable::ID, parent_id_);
   }
 
   std::set<syncable::ModelType> types_to_purge;
   types_to_purge.insert(syncable::BOOKMARKS);
   dir->PurgeEntriesWithTypeIn(types_to_purge);
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   dir->SaveChanges();
   {
-    ReadTransaction rt(dir, __FILE__, __LINE__);
+    ReadTransaction rt(dir, FROM_HERE);
     Entry entry(&rt, syncable::GET_BY_ID, parent_id_);
     ASSERT_FALSE(entry.good());
   }
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingTwoItemsTall) {
   CommitOrderingTest items[] = {
     {1, ids_.FromNumber(-1001), ids_.FromNumber(-1000)},
     {0, ids_.FromNumber(-1000), ids_.FromNumber(0)},
     CommitOrderingTest::LAST_COMMIT_ITEM,
@@ skipping 120 matching lines @@
   RunCommitOrderingTest(items);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingWithNesting) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   int64 now_server_time = ClientTimeToServerTime(syncable::Now());
   int64 now_minus_2h = ServerTimeToClientTime(now_server_time - 7200000);
 
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     {
       MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(),
                           "Bob");
       ASSERT_TRUE(parent.good());
       parent.Put(syncable::IS_UNSYNCED, true);
       parent.Put(syncable::IS_DIR, true);
       parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
       parent.Put(syncable::ID, ids_.FromNumber(100));
       parent.Put(syncable::BASE_VERSION, 1);
       MutableEntry child(&wtrans, syncable::CREATE, ids_.FromNumber(100),
@@ skipping 62 matching lines @@
   std::sort(commit_ids.begin() + 3, commit_ids.end());
   EXPECT_TRUE(ids_.FromNumber(103) == commit_ids[3]);
   EXPECT_TRUE(ids_.FromNumber(104) == commit_ids[4]);
   EXPECT_TRUE(ids_.FromNumber(105) == commit_ids[5]);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingWithNewItems) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(), "1");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNSYNCED, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::ID, parent_id_);
     MutableEntry child(&wtrans, syncable::CREATE, wtrans.root_id(), "2");
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     child.Put(syncable::ID, child_id_);
     parent.Put(syncable::BASE_VERSION, 1);
     child.Put(syncable::BASE_VERSION, 1);
   }
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans, syncable::CREATE, parent_id_, "A");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNSYNCED, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::ID, ids_.FromNumber(102));
     MutableEntry child(&wtrans, syncable::CREATE, parent_id_, "B");
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     child.Put(syncable::ID, ids_.FromNumber(-103));
     parent.Put(syncable::BASE_VERSION, 1);
   }
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans, syncable::CREATE, child_id_, "A");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNSYNCED, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::ID, ids_.FromNumber(-104));
     MutableEntry child(&wtrans, syncable::CREATE, child_id_, "B");
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
@@ skipping 14 matching lines @@
   EXPECT_TRUE(ids_.FromNumber(105) == mock_server_->committed_ids()[5]);
 }
 
 TEST_F(SyncerTest, TestCommitListOrderingCounterexample) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
 
   syncable::Id child2_id = ids_.NewServerId();
 
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(), "P");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNSYNCED, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::ID, parent_id_);
     MutableEntry child1(&wtrans, syncable::CREATE, parent_id_, "1");
     ASSERT_TRUE(child1.good());
     child1.Put(syncable::IS_UNSYNCED, true);
     child1.Put(syncable::ID, child_id_);
@@ skipping 20 matching lines @@
 
 TEST_F(SyncerTest, TestCommitListOrderingAndNewParent) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
 
   string parent1_name = "1";
   string parent2_name = "A";
   string child_name = "B";
 
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans, syncable::CREATE, wtrans.root_id(),
                         parent1_name);
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNSYNCED, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::ID, parent_id_);
     parent.Put(syncable::BASE_VERSION, 1);
   }
 
   syncable::Id parent2_id = ids_.NewLocalId();
   syncable::Id child_id = ids_.NewServerId();
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent2(&wtrans, syncable::CREATE, parent_id_, parent2_name);
     ASSERT_TRUE(parent2.good());
     parent2.Put(syncable::IS_UNSYNCED, true);
     parent2.Put(syncable::IS_DIR, true);
     parent2.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent2.Put(syncable::ID, parent2_id);
 
     MutableEntry child(&wtrans, syncable::CREATE, parent2_id, child_name);
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     child.Put(syncable::ID, child_id);
     child.Put(syncable::BASE_VERSION, 1);
   }
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   EXPECT_TRUE(3 == session_->status_controller()->unsynced_handles().size());
   ASSERT_TRUE(3 == mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(parent2_id == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(child_id == mock_server_->committed_ids()[2]);
   {
-    ReadTransaction rtrans(dir, __FILE__, __LINE__);
+    ReadTransaction rtrans(dir, FROM_HERE);
     // Check that things committed correctly.
     Entry entry_1(&rtrans, syncable::GET_BY_ID, parent_id_);
     EXPECT_EQ(entry_1.Get(NON_UNIQUE_NAME), parent1_name);
     // Check that parent2 is a subfolder of parent1.
     EXPECT_EQ(1, CountEntriesWithName(&rtrans,
                                       parent_id_,
                                       parent2_name));
 
     // Parent2 was a local ID and thus should have changed on commit!
     Entry pre_commit_entry_parent2(&rtrans, syncable::GET_BY_ID, parent2_id);
@@ skipping 11 matching lines @@
 
 TEST_F(SyncerTest, TestCommitListOrderingAndNewParentAndChild) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
 
   string parent_name = "1";
   string parent2_name = "A";
   string child_name = "B";
 
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans,
                         syncable::CREATE,
                         wtrans.root_id(),
                         parent_name);
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNSYNCED, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(syncable::ID, parent_id_);
     parent.Put(syncable::BASE_VERSION, 1);
   }
 
   int64 meta_handle_a, meta_handle_b;
   const Id parent2_local_id = ids_.NewLocalId();
   const Id child_local_id = ids_.NewLocalId();
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent2(&wtrans, syncable::CREATE, parent_id_, parent2_name);
     ASSERT_TRUE(parent2.good());
     parent2.Put(syncable::IS_UNSYNCED, true);
     parent2.Put(syncable::IS_DIR, true);
     parent2.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
 
     parent2.Put(syncable::ID, parent2_local_id);
     meta_handle_a = parent2.Get(syncable::META_HANDLE);
     MutableEntry child(&wtrans, syncable::CREATE, parent2_local_id, child_name);
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     child.Put(syncable::ID, child_local_id);
     meta_handle_b = child.Get(syncable::META_HANDLE);
   }
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   EXPECT_TRUE(3 == session_->status_controller()->unsynced_handles().size());
   ASSERT_TRUE(3 == mock_server_->committed_ids().size());
   // If this test starts failing, be aware other sort orders could be valid.
   EXPECT_TRUE(parent_id_ == mock_server_->committed_ids()[0]);
   EXPECT_TRUE(parent2_local_id == mock_server_->committed_ids()[1]);
   EXPECT_TRUE(child_local_id == mock_server_->committed_ids()[2]);
   {
-    ReadTransaction rtrans(dir, __FILE__, __LINE__);
+    ReadTransaction rtrans(dir, FROM_HERE);
 
     Entry parent(&rtrans, syncable::GET_BY_ID,
                  GetOnlyEntryWithName(&rtrans, rtrans.root_id(), parent_name));
     ASSERT_TRUE(parent.good());
     EXPECT_TRUE(parent.Get(syncable::ID).ServerKnows());
 
     Entry parent2(&rtrans, syncable::GET_BY_ID,
                   GetOnlyEntryWithName(&rtrans, parent.Get(ID), parent2_name));
     ASSERT_TRUE(parent2.good());
     EXPECT_TRUE(parent2.Get(syncable::ID).ServerKnows());
@@ skipping 42 matching lines @@
   ASSERT_TRUE(dir.good());
   string id = "some_id";
   string parent_id = "0";
   string name = "in_root";
   int64 version = 10;
   int64 timestamp = 10;
   mock_server_->AddUpdateDirectory(id, parent_id, name, version, timestamp);
 
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     Entry entry(&trans, GET_BY_ID,
                syncable::Id::CreateFromServerId("some_id"));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Get(IS_DIR));
     EXPECT_TRUE(entry.Get(SERVER_VERSION) == version);
     EXPECT_TRUE(entry.Get(BASE_VERSION) == version);
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
     EXPECT_FALSE(entry.Get(IS_DEL));
@@ skipping 38 matching lines @@
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   // The three items with an unresolved parent should be unapplied (3, 9, 100).
   // The name clash should also still be in conflict.
   EXPECT_EQ(3, status->TotalNumConflictingItems());
   {
     sessions::ScopedModelSafeGroupRestriction r(status, GROUP_PASSIVE);
     EXPECT_EQ(3, status->conflict_progress().ConflictingItemsSize());
   }
 
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     // Even though it has the same name, it should work.
     Entry name_clash(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(name_clash.good());
     EXPECT_FALSE(name_clash.Get(IS_UNAPPLIED_UPDATE))
         << "Duplicate name SHOULD be OK.";
 
     Entry bad_parent(&trans, GET_BY_ID, ids_.FromNumber(3));
     ASSERT_TRUE(bad_parent.good());
     EXPECT_TRUE(bad_parent.Get(IS_UNAPPLIED_UPDATE))
         << "child of unknown parent should be in conflict";
@@ skipping 16 matching lines @@
   mock_server_->AddUpdateDirectory(5, 6, "circular3", 20, 20);
 
   // Flip the is_dir bit: should fail verify & be dropped.
   mock_server_->AddUpdateBookmark(10, 0, "dir_to_bookmark", 20, 20);
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
 
   // Version number older than last known: should fail verify & be dropped.
   mock_server_->AddUpdateDirectory(4, 0, "old_version", 10, 10);
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry still_a_dir(&trans, GET_BY_ID, ids_.FromNumber(10));
     ASSERT_TRUE(still_a_dir.good());
     EXPECT_FALSE(still_a_dir.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(10 == still_a_dir.Get(BASE_VERSION));
     EXPECT_TRUE(10 == still_a_dir.Get(SERVER_VERSION));
     EXPECT_TRUE(still_a_dir.Get(IS_DIR));
 
     Entry rename(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(rename.good());
@@ skipping 43 matching lines @@
 }
 
 TEST_F(SyncerTest, CommitTimeRename) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   int64 metahandle_folder;
   int64 metahandle_new_entry;
 
   // Create a folder and an entry.
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&trans, CREATE, root_id_, "Folder");
     ASSERT_TRUE(parent.good());
     parent.Put(IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(IS_UNSYNCED, true);
     metahandle_folder = parent.Get(META_HANDLE);
 
     MutableEntry entry(&trans, CREATE, parent.Get(ID), "new_entry");
     ASSERT_TRUE(entry.good());
     metahandle_new_entry = entry.Get(META_HANDLE);
     WriteTestDataToEntry(&trans, &entry);
   }
 
   // Mix in a directory creation too for later.
   mock_server_->AddUpdateDirectory(2, 0, "dir_in_root", 10, 10);
   mock_server_->SetCommitTimeRename("renamed_");
   SyncShareAsDelegate();
 
   // Verify it was correctly renamed.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry_folder(&trans, GET_BY_HANDLE, metahandle_folder);
     ASSERT_TRUE(entry_folder.good());
     EXPECT_EQ("renamed_Folder", entry_folder.Get(NON_UNIQUE_NAME));
 
     Entry entry_new(&trans, GET_BY_HANDLE, metahandle_new_entry);
     ASSERT_TRUE(entry_new.good());
     EXPECT_EQ(entry_folder.Get(ID), entry_new.Get(PARENT_ID));
     EXPECT_EQ("renamed_new_entry", entry_new.Get(NON_UNIQUE_NAME));
 
     // And that the unrelated directory creation worked without a rename.
     Entry new_dir(&trans, GET_BY_ID, ids_.FromNumber(2));
     EXPECT_TRUE(new_dir.good());
     EXPECT_EQ("dir_in_root", new_dir.Get(NON_UNIQUE_NAME));
   }
 }
 
 
 TEST_F(SyncerTest, CommitTimeRenameI18N) {
   // This is utf-8 for the diacritized Internationalization.
   const char* i18nString = "\xc3\x8e\xc3\xb1\x74\xc3\xa9\x72\xc3\xb1"
       "\xc3\xa5\x74\xc3\xae\xc3\xb6\xc3\xb1\xc3\xa5\x6c\xc3\xae"
       "\xc2\x9e\xc3\xa5\x74\xc3\xae\xc3\xb6\xc3\xb1";
 
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   int64 metahandle;
   // Create a folder, expect a commit time rename.
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&trans, CREATE, root_id_, "Folder");
     ASSERT_TRUE(parent.good());
     parent.Put(IS_DIR, true);
     parent.Put(SPECIFICS, DefaultBookmarkSpecifics());
     parent.Put(IS_UNSYNCED, true);
     metahandle = parent.Get(META_HANDLE);
   }
 
   mock_server_->SetCommitTimeRename(i18nString);
   SyncShareAsDelegate();
 
   // Verify it was correctly renamed.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     string expected_folder_name(i18nString);
     expected_folder_name.append("Folder");
 
 
     Entry entry_folder(&trans, GET_BY_HANDLE, metahandle);
     ASSERT_TRUE(entry_folder.good());
     EXPECT_EQ(expected_folder_name, entry_folder.Get(NON_UNIQUE_NAME));
   }
 }
 
 // A commit with a lost response produces an update that has to be reunited with
 // its parent.
 TEST_F(SyncerTest, CommitReuniteUpdateAdjustsChildren) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
 
   // Create a folder in the root.
   int64 metahandle_folder;
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, CREATE, trans.root_id(), "new_folder");
     ASSERT_TRUE(entry.good());
     entry.Put(IS_DIR, true);
     entry.Put(SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(IS_UNSYNCED, true);
     metahandle_folder = entry.Get(META_HANDLE);
   }
 
   // Verify it and pull the ID out of the folder.
   syncable::Id folder_id;
   int64 metahandle_entry;
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_HANDLE, metahandle_folder);
     ASSERT_TRUE(entry.good());
     folder_id = entry.Get(ID);
     ASSERT_TRUE(!folder_id.ServerKnows());
   }
 
   // Create an entry in the newly created folder.
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, CREATE, folder_id, "new_entry");
     ASSERT_TRUE(entry.good());
     metahandle_entry = entry.Get(META_HANDLE);
     WriteTestDataToEntry(&trans, &entry);
   }
 
   // Verify it and pull the ID out of the entry.
   syncable::Id entry_id;
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, syncable::GET_BY_HANDLE, metahandle_entry);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(folder_id, entry.Get(PARENT_ID));
     EXPECT_EQ("new_entry", entry.Get(NON_UNIQUE_NAME));
     entry_id = entry.Get(ID);
     EXPECT_TRUE(!entry_id.ServerKnows());
     VerifyTestDataInEntry(&trans, &entry);
   }
 
   // Now, to emulate a commit response failure, we just don't commit it.
   int64 new_version = 150;  // any larger value.
   int64 timestamp = 20;  // arbitrary value.
   syncable::Id new_folder_id =
       syncable::Id::CreateFromServerId("folder_server_id");
 
   // The following update should cause the folder to both apply the update, as
   // well as reassociate the id.
   mock_server_->AddUpdateDirectory(new_folder_id, root_id_,
       "new_folder", new_version, timestamp);
   mock_server_->SetLastUpdateOriginatorFields(
       dir->cache_guid(), folder_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
   // Alright! Apply that update!
   SyncShareAsDelegate();
   {
     // The folder's ID should have been updated.
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry folder(&trans, GET_BY_HANDLE, metahandle_folder);
     ASSERT_TRUE(folder.good());
     EXPECT_EQ("new_folder", folder.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(new_version == folder.Get(BASE_VERSION));
     EXPECT_TRUE(new_folder_id == folder.Get(ID));
     EXPECT_TRUE(folder.Get(ID).ServerKnows());
     EXPECT_EQ(trans.root_id(), folder.Get(PARENT_ID));
 
     // Since it was updated, the old folder should not exist.
     Entry old_dead_folder(&trans, GET_BY_ID, folder_id);
@@ skipping 11 matching lines @@
 
 // A commit with a lost response produces an update that has to be reunited with
 // its parent.
 TEST_F(SyncerTest, CommitReuniteUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
 
   // Create an entry in the root.
   int64 entry_metahandle;
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, CREATE, trans.root_id(), "new_entry");
     ASSERT_TRUE(entry.good());
     entry_metahandle = entry.Get(META_HANDLE);
     WriteTestDataToEntry(&trans, &entry);
   }
 
   // Verify it and pull the ID out.
   syncable::Id entry_id;
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     entry_id = entry.Get(ID);
     EXPECT_TRUE(!entry_id.ServerKnows());
     VerifyTestDataInEntry(&trans, &entry);
   }
 
   // Now, to emulate a commit response failure, we just don't commit it.
   int64 new_version = 150;  // any larger value.
   int64 timestamp = 20;  // arbitrary value.
   syncable::Id new_entry_id = syncable::Id::CreateFromServerId("server_id");
 
   // Generate an update from the server with a relevant ID reassignment.
   mock_server_->AddUpdateBookmark(new_entry_id, root_id_,
       "new_entry", new_version, timestamp);
   mock_server_->SetLastUpdateOriginatorFields(
       dir->cache_guid(), entry_id.GetServerId());
 
   // We don't want it accidentally committed, just the update applied.
   mock_server_->set_conflict_all_commits(true);
 
   // Alright! Apply that update!
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(new_version == entry.Get(BASE_VERSION));
     EXPECT_TRUE(new_entry_id == entry.Get(ID));
     EXPECT_EQ("new_entry", entry.Get(NON_UNIQUE_NAME));
   }
 }
 
 // A commit with a lost response must work even if the local entry was deleted
 // before the update is applied. We should not duplicate the local entry in
 // this case, but just create another one alongside. We may wish to examine
 // this behavior in the future as it can create hanging uploads that never
 // finish, that must be cleaned up on the server side after some time.
 TEST_F(SyncerTest, CommitReuniteUpdateDoesNotChokeOnDeletedLocalEntry) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
 
   // Create a entry in the root.
   int64 entry_metahandle;
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, CREATE, trans.root_id(), "new_entry");
     ASSERT_TRUE(entry.good());
     entry_metahandle = entry.Get(META_HANDLE);
     WriteTestDataToEntry(&trans, &entry);
   }
   // Verify it and pull the ID out.
   syncable::Id entry_id;
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     entry_id = entry.Get(ID);
     EXPECT_TRUE(!entry_id.ServerKnows());
     VerifyTestDataInEntry(&trans, &entry);
   }
 
   // Now, to emulate a commit response failure, we just don't commit it.
   int64 new_version = 150;  // any larger value.
   int64 timestamp = 20;  // arbitrary value.
   syncable::Id new_entry_id = syncable::Id::CreateFromServerId("server_id");
 
   // Generate an update from the server with a relevant ID reassignment.
   mock_server_->AddUpdateBookmark(new_entry_id, root_id_,
       "new_entry", new_version, timestamp);
   mock_server_->SetLastUpdateOriginatorFields(
       dir->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(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     Id new_entry_id = GetOnlyEntryWithName(
         &trans, trans.root_id(), "new_entry");
     MutableEntry entry(&trans, GET_BY_ID, new_entry_id);
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::IS_DEL, true);
   }
 
   // Just don't CHECK fail in sync, have the update split.
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Id new_entry_id = GetOnlyEntryWithName(
         &trans, trans.root_id(), "new_entry");
     Entry entry(&trans, GET_BY_ID, new_entry_id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_DEL));
 
     Entry old_entry(&trans, GET_BY_ID, entry_id);
     ASSERT_TRUE(old_entry.good());
     EXPECT_TRUE(old_entry.Get(IS_DEL));
   }
 }
 
 // TODO(chron): Add more unsanitized name tests.
 TEST_F(SyncerTest, ConflictMatchingEntryHandlesUnsanitizedNames) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A/A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B/B", 10, 10);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
 
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     A.Put(IS_UNAPPLIED_UPDATE, true);
     A.Put(SERVER_VERSION, 20);
 
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.Put(IS_UNAPPLIED_UPDATE, true);
     B.Put(SERVER_VERSION, 20);
   }
   LoopSyncShare();
   saw_syncer_event_ = false;
   mock_server_->set_conflict_all_commits(false);
 
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry A(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     EXPECT_TRUE(A.Get(IS_UNSYNCED) == false);
     EXPECT_TRUE(A.Get(IS_UNAPPLIED_UPDATE) == false);
     EXPECT_TRUE(A.Get(SERVER_VERSION) == 20);
 
     Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_TRUE(B.Get(IS_UNSYNCED) == false);
     EXPECT_TRUE(B.Get(IS_UNAPPLIED_UPDATE) == false);
     EXPECT_TRUE(B.Get(SERVER_VERSION) == 20);
   }
 }
 
 TEST_F(SyncerTest, ConflictMatchingEntryHandlesNormalNames) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
 
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     A.Put(IS_UNAPPLIED_UPDATE, true);
     A.Put(SERVER_VERSION, 20);
 
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.Put(IS_UNAPPLIED_UPDATE, true);
     B.Put(SERVER_VERSION, 20);
   }
   LoopSyncShare();
   saw_syncer_event_ = false;
   mock_server_->set_conflict_all_commits(false);
 
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry A(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     EXPECT_TRUE(A.Get(IS_UNSYNCED) == false);
     EXPECT_TRUE(A.Get(IS_UNAPPLIED_UPDATE) == false);
     EXPECT_TRUE(A.Get(SERVER_VERSION) == 20);
 
     Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_TRUE(B.Get(IS_UNSYNCED) == false);
     EXPECT_TRUE(B.Get(IS_UNAPPLIED_UPDATE) == false);
     EXPECT_TRUE(B.Get(SERVER_VERSION) == 20);
   }
 }
 
 TEST_F(SyncerTest, ReverseFolderOrderingTest) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   mock_server_->AddUpdateDirectory(4, 3, "ggchild", 10, 10);
   mock_server_->AddUpdateDirectory(3, 2, "gchild", 10, 10);
   mock_server_->AddUpdateDirectory(5, 4, "gggchild", 10, 10);
   mock_server_->AddUpdateDirectory(2, 1, "child", 10, 10);
   mock_server_->AddUpdateDirectory(1, 0, "parent", 10, 10);
   LoopSyncShare();
-  ReadTransaction trans(dir, __FILE__, __LINE__);
+  ReadTransaction trans(dir, FROM_HERE);
 
   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() {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     CHECK(dir.good());
 
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans,
                      syncable::GET_BY_ID,
                      GetOnlyEntryWithName(&trans,
                                           TestIdFactory::root(),
                                           "bob"));
     CHECK(bob.good());
 
     MutableEntry entry2(&trans, syncable::CREATE, bob.Get(syncable::ID),
                         "bob");
     CHECK(entry2.good());
     entry2.Put(syncable::IS_DIR, true);
     entry2.Put(syncable::IS_UNSYNCED, true);
     entry2.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
   }
 };
 
 TEST_F(EntryCreatedInNewFolderTest, EntryCreatedInNewFolderMidSync) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   dir->set_store_birthday(mock_server_->store_birthday());
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, syncable::CREATE, trans.root_id(),
                        "bob");
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::IS_DIR, true);
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
   }
 
   mock_server_->SetMidCommitCallback(
       NewCallback<EntryCreatedInNewFolderTest>(this,
           &EntryCreatedInNewFolderTest::CreateFolderInBob));
   syncer_->SyncShare(session_.get(), BUILD_COMMIT_REQUEST, SYNCER_END);
   EXPECT_TRUE(1 == mock_server_->committed_ids().size());
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry parent_entry(&trans, syncable::GET_BY_ID,
         GetOnlyEntryWithName(&trans, TestIdFactory::root(), "bob"));
     ASSERT_TRUE(parent_entry.good());
 
     Id child_id =
         GetOnlyEntryWithName(&trans, parent_entry.Get(ID), "bob");
     Entry child(&trans, syncable::GET_BY_ID, child_id);
     ASSERT_TRUE(child.good());
     EXPECT_EQ(parent_entry.Get(ID), child.Get(PARENT_ID));
 }
 }
 
 TEST_F(SyncerTest, NegativeIDInUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateBookmark(-10, 0, "bad", 40, 40);
   SyncShareAsDelegate();
   // The negative id would make us CHECK!
 }
 
 TEST_F(SyncerTest, UnappliedUpdateOnCreatedItemItemDoesNotCrash) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   int64 metahandle_fred;
   {
     // Create an item.
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry fred_match(&trans, CREATE, trans.root_id(),
                             "fred_match");
     ASSERT_TRUE(fred_match.good());
     metahandle_fred = fred_match.Get(META_HANDLE);
     WriteTestDataToEntry(&trans, &fred_match);
   }
   // Commit it.
   SyncShareAsDelegate();
   EXPECT_TRUE(1 == 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(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry fred_match(&trans, GET_BY_HANDLE, metahandle_fred);
     ASSERT_TRUE(fred_match.good());
     EXPECT_TRUE(fred_match.Get(ID).ServerKnows());
     fred_match_id = fred_match.Get(ID);
     mock_server_->AddUpdateBookmark(fred_match_id, trans.root_id(),
         "fred_match", 40, 40);
   }
   // Run the syncer.
   for (int i = 0 ; i < 30 ; ++i) {
     SyncShareAsDelegate();
   }
 }
 
 /**
  * In the event that we have a double changed entry, that is changed on both
  * the client and the server, the conflict resolver should just drop one of
  * them and accept the other.
  */
 
 TEST_F(SyncerTest, DoublyChangedWithResolver) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans, syncable::CREATE, root_id_, "Folder");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::ID, parent_id_);
     parent.Put(syncable::BASE_VERSION, 5);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     MutableEntry child(&wtrans, syncable::CREATE, parent_id_, "Pete.htm");
     ASSERT_TRUE(child.good());
     child.Put(syncable::ID, child_id_);
     child.Put(syncable::BASE_VERSION, 10);
     WriteTestDataToEntry(&wtrans, &child);
   }
   mock_server_->AddUpdateBookmark(child_id_, parent_id_, "Pete2.htm", 11, 10);
   mock_server_->set_conflict_all_commits(true);
   LoopSyncShare();
   syncable::Directory::ChildHandles children;
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     dir->GetChildHandlesById(&trans, parent_id_, &children);
     // We expect the conflict resolver to preserve the local entry.
     Entry child(&trans, syncable::GET_BY_ID, child_id_);
     ASSERT_TRUE(child.good());
     EXPECT_TRUE(child.Get(syncable::IS_UNSYNCED));
     EXPECT_FALSE(child.Get(syncable::IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(child.Get(SPECIFICS).HasExtension(sync_pb::bookmark));
     EXPECT_EQ("Pete.htm", child.Get(NON_UNIQUE_NAME));
     VerifyTestBookmarkDataInEntry(&child);
   }
 
   // Only one entry, since we just overwrite one.
   EXPECT_TRUE(1 == children.size());
   saw_syncer_event_ = false;
 }
 
 // We got this repro case when someone was editing bookmarks while sync was
 // occuring. The entry had changed out underneath the user.
 TEST_F(SyncerTest, CommitsUpdateDoesntAlterEntry) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   int64 test_time = 123456;
   int64 entry_metahandle;
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&wtrans, syncable::CREATE, root_id_, "Pete");
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(ID).ServerKnows());
     entry.Put(syncable::IS_DIR, true);
     entry.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::MTIME, test_time);
     entry_metahandle = entry.Get(META_HANDLE);
   }
   SyncShareAsDelegate();
   syncable::Id id;
   int64 version;
   int64 server_position_in_parent;
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, syncable::GET_BY_HANDLE, entry_metahandle);
     ASSERT_TRUE(entry.good());
     id = entry.Get(ID);
     EXPECT_TRUE(id.ServerKnows());
     version = entry.Get(BASE_VERSION);
     server_position_in_parent = entry.Get(SERVER_POSITION_IN_PARENT);
   }
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   EXPECT_EQ("Pete", update->name());
   EXPECT_EQ(id.GetServerId(), update->id_string());
   EXPECT_EQ(root_id_.GetServerId(), update->parent_id_string());
   EXPECT_EQ(version, update->version());
   EXPECT_EQ(server_position_in_parent, update->position_in_parent());
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, syncable::GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Get(MTIME) == test_time);
   }
 }
 
 TEST_F(SyncerTest, ParentAndChildBothMatch) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   syncable::Id parent_id = ids_.NewServerId();
   syncable::Id child_id = ids_.NewServerId();
 
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans, CREATE, root_id_, "Folder");
     ASSERT_TRUE(parent.good());
     parent.Put(IS_DIR, true);
     parent.Put(IS_UNSYNCED, true);
     parent.Put(ID, parent_id);
     parent.Put(BASE_VERSION, 1);
     parent.Put(SPECIFICS, DefaultBookmarkSpecifics());
 
     MutableEntry child(&wtrans, CREATE, parent.Get(ID), "test.htm");
     ASSERT_TRUE(child.good());
     child.Put(ID, child_id);
     child.Put(BASE_VERSION, 1);
     child.Put(SPECIFICS, DefaultBookmarkSpecifics());
     WriteTestDataToEntry(&wtrans, &child);
   }
   mock_server_->AddUpdateDirectory(parent_id, root_id_, "Folder", 10, 10);
   mock_server_->AddUpdateBookmark(child_id, parent_id, "test.htm", 10, 10);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Directory::ChildHandles children;
     dir->GetChildHandlesById(&trans, root_id_, &children);
     EXPECT_TRUE(1 == children.size());
     dir->GetChildHandlesById(&trans, parent_id, &children);
     EXPECT_TRUE(1 == children.size());
     Directory::UnappliedUpdateMetaHandles unapplied;
     dir->GetUnappliedUpdateMetaHandles(&trans, &unapplied);
     EXPECT_TRUE(0 == unapplied.size());
     syncable::Directory::UnsyncedMetaHandles unsynced;
     dir->GetUnsyncedMetaHandles(&trans, &unsynced);
     EXPECT_TRUE(0 == unsynced.size());
     saw_syncer_event_ = false;
   }
 }
 
 TEST_F(SyncerTest, CommittingNewDeleted) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, CREATE, trans.root_id(), "bob");
     entry.Put(IS_UNSYNCED, true);
     entry.Put(IS_DEL, true);
   }
   SyncShareAsDelegate();
   EXPECT_TRUE(0 == mock_server_->committed_ids().size());
 }
 
 // Original problem synopsis:
 // Check failed: entry->Get(BASE_VERSION) <= entry->Get(SERVER_VERSION)
 // Client creates entry, client finishes committing entry. Between
 // commit and getting update back, we delete the entry.
 // We get the update for the entry, but the local one was modified
 // so we store the entry but don't apply it. IS_UNAPPLIED_UPDATE is set.
 // We commit deletion and get a new version number.
 // We apply unapplied updates again before we get the update about the deletion.
 // This means we have an unapplied update where server_version < base_version.
 TEST_F(SyncerTest, UnappliedUpdateDuringCommit) {
   // This test is a little fake.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, CREATE, trans.root_id(), "bob");
     entry.Put(ID, ids_.FromNumber(20));
     entry.Put(BASE_VERSION, 1);
     entry.Put(SERVER_VERSION, 1);
     entry.Put(SERVER_PARENT_ID, ids_.FromNumber(9999));  // Bad parent.
     entry.Put(IS_UNSYNCED, true);
     entry.Put(IS_UNAPPLIED_UPDATE, true);
     entry.Put(SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(SERVER_SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(IS_DEL, false);
@@ skipping 14 matching lines @@
 //   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.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   int64 existing_metahandle;
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, CREATE, trans.root_id(), "existing");
     ASSERT_TRUE(entry.good());
     entry.Put(IS_DIR, true);
     entry.Put(SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(IS_UNSYNCED, true);
     existing_metahandle = entry.Get(META_HANDLE);
   }
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry newfolder(&trans, CREATE, trans.root_id(), "new");
     ASSERT_TRUE(newfolder.good());
     newfolder.Put(IS_DIR, true);
     newfolder.Put(SPECIFICS, DefaultBookmarkSpecifics());
     newfolder.Put(IS_UNSYNCED, true);
 
     MutableEntry existing(&trans, GET_BY_HANDLE, existing_metahandle);
     ASSERT_TRUE(existing.good());
     existing.Put(PARENT_ID, newfolder.Get(ID));
     existing.Put(IS_UNSYNCED, true);
     EXPECT_TRUE(existing.Get(ID).ServerKnows());
 
     newfolder.Put(IS_DEL, true);
     existing.Put(IS_DEL, true);
   }
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   StatusController* status(session_->status_controller());
   EXPECT_TRUE(0 == status->error_counters().num_conflicting_commits);
 }
 
 TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   int64 newfolder_metahandle;
 
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry newfolder(&trans, CREATE, ids_.FromNumber(1), "local");
     ASSERT_TRUE(newfolder.good());
     newfolder.Put(IS_UNSYNCED, true);
     newfolder.Put(IS_DIR, true);
     newfolder.Put(SPECIFICS, DefaultBookmarkSpecifics());
     newfolder_metahandle = newfolder.Get(META_HANDLE);
   }
   mock_server_->AddUpdateDirectory(1, 0, "bob", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, APPLY_UPDATES);
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, syncable::GET_BY_HANDLE, newfolder_metahandle);
     ASSERT_TRUE(entry.good());
   }
 }
 
 TEST_F(SyncerTest, FolderSwapUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10);
   SyncShareAsDelegate();
   mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20);
   mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20);
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_TRUE("fred" == id1.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id1.Get(PARENT_ID));
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_TRUE("bob" == id2.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id2.Get(PARENT_ID));
   }
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, NameCollidingFolderSwapWorksFine) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(1024, 0, "fred", 1, 10);
   mock_server_->AddUpdateDirectory(4096, 0, "alice", 1, 10);
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_TRUE("bob" == id1.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id1.Get(PARENT_ID));
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_TRUE("fred" == id2.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id2.Get(PARENT_ID));
     Entry id3(&trans, GET_BY_ID, ids_.FromNumber(4096));
     ASSERT_TRUE(id3.good());
     EXPECT_TRUE("alice" == id3.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id3.Get(PARENT_ID));
   }
   mock_server_->AddUpdateDirectory(1024, 0, "bob", 2, 20);
   mock_server_->AddUpdateDirectory(7801, 0, "fred", 2, 20);
   mock_server_->AddUpdateDirectory(4096, 0, "bob", 2, 20);
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry id1(&trans, GET_BY_ID, ids_.FromNumber(7801));
     ASSERT_TRUE(id1.good());
     EXPECT_TRUE("fred" == id1.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id1.Get(PARENT_ID));
     Entry id2(&trans, GET_BY_ID, ids_.FromNumber(1024));
     ASSERT_TRUE(id2.good());
     EXPECT_TRUE("bob" == id2.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id2.Get(PARENT_ID));
     Entry id3(&trans, GET_BY_ID, ids_.FromNumber(4096));
     ASSERT_TRUE(id3.good());
     EXPECT_TRUE("bob" == id3.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(root_id_ == id3.Get(PARENT_ID));
   }
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, CommitManyItemsInOneGo) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   uint32 max_batches = 3;
   uint32 items_to_commit = kDefaultMaxCommitBatchSize * max_batches;
   CHECK(dir.good());
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     for (uint32 i = 0; i < items_to_commit; i++) {
       string nameutf8 = base::StringPrintf("%d", i);
       string name(nameutf8.begin(), nameutf8.end());
       MutableEntry e(&trans, CREATE, trans.root_id(), name);
       e.Put(IS_UNSYNCED, true);
       e.Put(IS_DIR, true);
       e.Put(SPECIFICS, DefaultBookmarkSpecifics());
     }
   }
   uint32 num_loops = 0;
   while (SyncShareAsDelegate()) {
     num_loops++;
     ASSERT_LT(num_loops, max_batches * 2);
   }
   EXPECT_GE(mock_server_->commit_messages().size(), max_batches);
 }
 
 TEST_F(SyncerTest, HugeConflict) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   int item_count = 300;  // We should be able to do 300 or 3000 w/o issue.
   CHECK(dir.good());
 
   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(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     for (int i = 0; i < item_count ; i++) {
       syncable::Id next_id = ids_.NewServerId();
       tree_ids.push_back(next_id);
       mock_server_->AddUpdateDirectory(next_id, last_id, "BOB", 2, 20);
       last_id = next_id;
     }
   }
   SyncShareAsDelegate();
 
   // Check they're in the expected conflict state.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     for (int i = 0; i < item_count; i++) {
       Entry e(&trans, GET_BY_ID, tree_ids[i]);
       // They should all exist but none should be applied.
       ASSERT_TRUE(e.good());
       EXPECT_TRUE(e.Get(IS_DEL));
       EXPECT_TRUE(e.Get(IS_UNAPPLIED_UPDATE));
     }
   }
 
   // Add the missing parent directory.
   mock_server_->AddUpdateDirectory(parent_id, TestIdFactory::root(),
       "BOB", 2, 20);
   SyncShareAsDelegate();
 
   // Now they should all be OK.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     for (int i = 0; i < item_count; i++) {
       Entry e(&trans, GET_BY_ID, tree_ids[i]);
       ASSERT_TRUE(e.good());
       EXPECT_FALSE(e.Get(IS_DEL));
       EXPECT_FALSE(e.Get(IS_UNAPPLIED_UPDATE));
     }
   }
 }
 
 TEST_F(SyncerTest, DontCrashOnCaseChange) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry e(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(e.good());
     e.Put(IS_UNSYNCED, true);
   }
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(1, 0, "BOB", 2, 20);
   SyncShareAsDelegate();  // USED TO CAUSE AN ASSERT
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, UnsyncedItemAndUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   SyncShareAsDelegate();
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(2, 0, "bob", 2, 20);
   SyncShareAsDelegate();  // USED TO CAUSE AN ASSERT
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10);
   SyncShareAsDelegate();
   int64 local_folder_handle;
   syncable::Id local_folder_id;
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry new_entry(&wtrans, CREATE, wtrans.root_id(), "Bar.htm");
     ASSERT_TRUE(new_entry.good());
     local_folder_id = new_entry.Get(ID);
     local_folder_handle = new_entry.Get(META_HANDLE);
     new_entry.Put(IS_UNSYNCED, true);
     new_entry.Put(SPECIFICS, DefaultBookmarkSpecifics());
     MutableEntry old(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(old.good());
     WriteTestDataToEntry(&wtrans, &old);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 20, 20);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   saw_syncer_event_ = false;
   {
     // Update #20 should have been dropped in favor of the local version.
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_TRUE(local.Get(META_HANDLE) != server.Get(META_HANDLE));
     EXPECT_FALSE(server.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(local.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(server.Get(IS_UNSYNCED));
     EXPECT_TRUE(local.Get(IS_UNSYNCED));
     EXPECT_EQ("Foo.htm", server.Get(NON_UNIQUE_NAME));
     EXPECT_EQ("Bar.htm", local.Get(NON_UNIQUE_NAME));
   }
   // Allow local changes to commit.
   mock_server_->set_conflict_all_commits(false);
   SyncShareAsDelegate();
   saw_syncer_event_ = false;
 
   // Now add a server change to make the two names equal.  There should
   // be no conflict with that, since names are not unique.
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 30, 30);
   SyncShareAsDelegate();
   saw_syncer_event_ = false;
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_TRUE(local.Get(META_HANDLE) != server.Get(META_HANDLE));
     EXPECT_FALSE(server.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(local.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(server.Get(IS_UNSYNCED));
     EXPECT_FALSE(local.Get(IS_UNSYNCED));
     EXPECT_EQ("Bar.htm", server.Get(NON_UNIQUE_NAME));
     EXPECT_EQ("Bar.htm", local.Get(NON_UNIQUE_NAME));
     EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
         server.Get(SPECIFICS).GetExtension(sync_pb::bookmark).url());
   }
 }
 
 // Same as NewEntryAnddServerEntrySharePath, but using the old-style protocol.
 TEST_F(SyncerTest, NewEntryAndAlteredServerEntrySharePath_OldBookmarksProto) {
   mock_server_->set_use_legacy_bookmarks_protocol(true);
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateBookmark(1, 0, "Foo.htm", 10, 10);
   SyncShareAsDelegate();
   int64 local_folder_handle;
   syncable::Id local_folder_id;
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry new_entry(&wtrans, CREATE, wtrans.root_id(), "Bar.htm");
     ASSERT_TRUE(new_entry.good());
     local_folder_id = new_entry.Get(ID);
     local_folder_handle = new_entry.Get(META_HANDLE);
     new_entry.Put(IS_UNSYNCED, true);
     new_entry.Put(SPECIFICS, DefaultBookmarkSpecifics());
     MutableEntry old(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(old.good());
     WriteTestDataToEntry(&wtrans, &old);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 20, 20);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   saw_syncer_event_ = false;
   {
     // Update #20 should have been dropped in favor of the local version.
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_TRUE(local.Get(META_HANDLE) != server.Get(META_HANDLE));
     EXPECT_FALSE(server.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(local.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(server.Get(IS_UNSYNCED));
     EXPECT_TRUE(local.Get(IS_UNSYNCED));
     EXPECT_EQ("Foo.htm", server.Get(NON_UNIQUE_NAME));
     EXPECT_EQ("Bar.htm", local.Get(NON_UNIQUE_NAME));
   }
   // Allow local changes to commit.
   mock_server_->set_conflict_all_commits(false);
   SyncShareAsDelegate();
   saw_syncer_event_ = false;
 
   // Now add a server change to make the two names equal.  There should
   // be no conflict with that, since names are not unique.
   mock_server_->AddUpdateBookmark(1, 0, "Bar.htm", 30, 30);
   SyncShareAsDelegate();
   saw_syncer_event_ = false;
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry server(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     MutableEntry local(&wtrans, GET_BY_HANDLE, local_folder_handle);
     ASSERT_TRUE(server.good());
     ASSERT_TRUE(local.good());
     EXPECT_TRUE(local.Get(META_HANDLE) != server.Get(META_HANDLE));
     EXPECT_FALSE(server.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(local.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(server.Get(IS_UNSYNCED));
     EXPECT_FALSE(local.Get(IS_UNSYNCED));
     EXPECT_EQ("Bar.htm", server.Get(NON_UNIQUE_NAME));
     EXPECT_EQ("Bar.htm", local.Get(NON_UNIQUE_NAME));
     EXPECT_EQ("http://google.com",  // Default from AddUpdateBookmark.
         server.Get(SPECIFICS).GetExtension(sync_pb::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.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     ASSERT_TRUE(A.Put(PARENT_ID, ids_.FromNumber(2)));
     ASSERT_TRUE(A.Put(NON_UNIQUE_NAME, "B"));
   }
   mock_server_->AddUpdateDirectory(2, 1, "A", 20, 20);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   saw_syncer_event_ = false;
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_TRUE(A.Get(NON_UNIQUE_NAME) == "B");
     EXPECT_TRUE(B.Get(NON_UNIQUE_NAME) == "B");
   }
 }
 
 TEST_F(SyncerTest, ConflictSetClassificationError) {
   // This code used to cause a CHECK failure because we incorrectly thought
   // a set was only unapplied updates.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     A.Put(IS_UNAPPLIED_UPDATE, true);
     A.Put(SERVER_NON_UNIQUE_NAME, "B");
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.Put(IS_UNAPPLIED_UPDATE, true);
     B.Put(SERVER_NON_UNIQUE_NAME, "A");
   }
   SyncShareAsDelegate();
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, SwapEntryNames) {
   // Simple transaction test.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateDirectory(2, 0, "B", 10, 10);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     MutableEntry B(&wtrans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     B.Put(IS_UNSYNCED, true);
     ASSERT_TRUE(A.Put(NON_UNIQUE_NAME, "C"));
     ASSERT_TRUE(B.Put(NON_UNIQUE_NAME, "A"));
     ASSERT_TRUE(A.Put(NON_UNIQUE_NAME, "B"));
   }
   SyncShareAsDelegate();
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, DualDeletionWithNewItemNameClash) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10);
   mock_server_->AddUpdateBookmark(2, 0, "B", 10, 10);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     WriteTestDataToEntry(&trans, &B);
     B.Put(IS_DEL, true);
   }
   mock_server_->AddUpdateBookmark(2, 0, "A", 11, 11);
   mock_server_->SetLastUpdateDeleted();
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry B(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(B.good());
     EXPECT_FALSE(B.Get(IS_UNSYNCED));
     EXPECT_FALSE(B.Get(IS_UNAPPLIED_UPDATE));
   }
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, FixDirectoryLoopConflict) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(2, 0, "fred", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, ids_.FromNumber(2));
   }
   mock_server_->AddUpdateDirectory(2, 1, "fred", 2, 20);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     Entry fred(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(fred.good());
     EXPECT_TRUE(fred.Get(IS_UNSYNCED));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_FALSE(fred.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
   }
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, ResolveWeWroteTheyDeleted) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   int64 bob_metahandle;
 
   mock_server_->AddUpdateBookmark(1, 0, "bob", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob_metahandle = bob.Get(META_HANDLE);
     WriteTestDataToEntry(&trans, &bob);
   }
   mock_server_->AddUpdateBookmark(1, 0, "bob", 2, 10);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_HANDLE, bob_metahandle);
     ASSERT_TRUE(bob.good());
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_FALSE(bob.Get(ID).ServerKnows());
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(bob.Get(IS_DEL));
   }
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, ServerDeletingFolderWeHaveMovedSomethingInto) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   syncable::Id bob_id = ids_.NewServerId();
   syncable::Id fred_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, fred_id);
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(bob.Get(NON_UNIQUE_NAME) == "bob");
     EXPECT_NE(bob.Get(PARENT_ID), fred_id);
 
     // Entry was deleted and reborn.
     Entry dead_fred(&trans, GET_BY_ID, fred_id);
@@ skipping 15 matching lines @@
 // TODO(chron): The fourth time that SyncShare is called it crashes.
 // This seems to be due to a bug in the conflict set building logic.
 // http://crbug.com/46621
 TEST_F(SyncerTest, DISABLED_ServerDeletingFolderWeHaveAnOpenEntryIn) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateBookmark(1, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(2, 0, "fred", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     WriteTestDataToEntry(&trans, &bob);
   }
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     EXPECT_FALSE(bob.Get(IS_UNSYNCED));
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, ids_.FromNumber(2));
   }
   mock_server_->AddUpdateDirectory(2, 0, "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   saw_syncer_event_ = false;
   // These SyncShares would cause a CHECK because we'd think we were stuck.
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   EXPECT_FALSE(saw_syncer_event_);
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     Id fred_id =
         GetOnlyEntryWithName(&trans, TestIdFactory::root(), "fred");
     Entry fred(&trans, GET_BY_ID, fred_id);
     ASSERT_TRUE(fred.good());
     EXPECT_FALSE(fred.Get(IS_UNSYNCED));
     EXPECT_TRUE(fred.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(bob.Get(PARENT_ID) == fred.Get(ID));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
   }
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, WeMovedSomethingIntoAFolderServerHasDeleted) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   syncable::Id bob_id = ids_.NewServerId();
   syncable::Id fred_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     Entry fred(&trans, GET_BY_ID, fred_id);
     ASSERT_TRUE(fred.good());
 
     MutableEntry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, fred_id);
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
 
     // Entry was deleted by server. We'll make a new one though with a new ID.
     Entry dead_fred(&trans, GET_BY_ID, fred_id);
     EXPECT_FALSE(dead_fred.good());
 
     // Fred is reborn with a local ID.
     Entry fred(&trans, GET_BY_ID, bob.Get(PARENT_ID));
     EXPECT_EQ("fred", fred.Get(NON_UNIQUE_NAME));
@@ skipping 23 matching lines @@
       MoveBobIntoID2();
       done_ = true;
     }
   }
 
  protected:
   void MoveBobIntoID2() {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     CHECK(dir.good());
 
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     Entry alice(&trans, GET_BY_ID,
                 TestIdFactory::FromNumber(fred_id_number));
     CHECK(alice.good());
     EXPECT_TRUE(!alice.Get(IS_DEL));
     EXPECT_TRUE(alice.Get(SYNCING)) << "Expected to be called mid-commit.";
     MutableEntry bob(&trans, GET_BY_ID,
                      TestIdFactory::FromNumber(bob_id_number));
     CHECK(bob.good());
     bob.Put(IS_UNSYNCED, true);
 
@@ skipping 13 matching lines @@
       FolderMoveDeleteRenameTest::bob_id_number);
   const syncable::Id fred_id = TestIdFactory::FromNumber(
       FolderMoveDeleteRenameTest::fred_id_number);
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry fred(&trans, GET_BY_ID, fred_id);
     ASSERT_TRUE(fred.good());
     fred.Put(IS_UNSYNCED, true);
     fred.Put(SYNCING, false);
     fred.Put(NON_UNIQUE_NAME, "Alice");
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   // This test is a little brittle. We want to move the item into the folder
   // such that we think we're dealing with a simple conflict, but in reality
   // it's actually a conflict set.
   mock_server_->SetMidCommitCallback(
       NewCallback<FolderMoveDeleteRenameTest>(this,
           &FolderMoveDeleteRenameTest::MoveBobIntoID2Runner));
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
 
     // Old entry is dead
     Entry dead_fred(&trans, GET_BY_ID, fred_id);
     EXPECT_FALSE(dead_fred.good());
 
     // New ID is created to fill parent folder, named correctly
     Entry alice(&trans, GET_BY_ID, bob.Get(PARENT_ID));
     ASSERT_TRUE(alice.good());
@@ skipping 18 matching lines @@
   syncable::Id bob_id = ids_.NewServerId();
   syncable::Id fred_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 1, 10);
   SyncShareAsDelegate();
   syncable::Id new_item_id;
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, fred_id);
     MutableEntry new_item(&trans, CREATE, fred_id, "new_item");
     WriteTestDataToEntry(&trans, &new_item);
     new_item_id = new_item.Get(ID);
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_NE(bob.Get(PARENT_ID), fred_id);
 
     // Was recreated. Old one shouldn't exist.
     Entry dead_fred(&trans, GET_BY_ID, fred_id);
     EXPECT_FALSE(dead_fred.good());
@@ skipping 13 matching lines @@
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, ServerMovedSomethingIntoAFolderWeHaveDeleted) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(2, 0, "fred", 1, 10);
   LoopSyncShare();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(IS_DEL, true);
   }
   mock_server_->AddUpdateDirectory(2, 1, "fred", 2, 20);
   mock_server_->set_conflict_all_commits(true);
   LoopSyncShare();
   LoopSyncShare();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     Entry fred(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(fred.good());
     EXPECT_FALSE(fred.Get(IS_UNSYNCED));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_TRUE(fred.Get(PARENT_ID) == bob.Get(ID));
     EXPECT_TRUE(bob.Get(PARENT_ID) == root_id_);
     EXPECT_FALSE(fred.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
   }
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, ServerMovedAFolderIntoAFolderWeHaveDeletedAndMovedIntoIt) {
   // This test combines circular folders and deleted parents.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(2, 0, "fred", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(IS_DEL, true);
     bob.Put(PARENT_ID, ids_.FromNumber(2));
   }
   mock_server_->AddUpdateDirectory(2, 1, "fred", 2, 20);
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     Entry fred(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(fred.good());
     EXPECT_TRUE(fred.Get(IS_UNSYNCED));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_TRUE(bob.Get(IS_DEL));
     EXPECT_TRUE(fred.Get(PARENT_ID) == root_id_);
     EXPECT_TRUE(bob.Get(PARENT_ID) == fred.Get(ID));
     EXPECT_FALSE(fred.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
   }
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, NewServerItemInAFolderWeHaveDeleted) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   LoopSyncShare();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(IS_DEL, true);
   }
   mock_server_->AddUpdateDirectory(2, 1, "fred", 2, 20);
   mock_server_->set_conflict_all_commits(true);
   LoopSyncShare();
   LoopSyncShare();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     Entry fred(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(fred.good());
     EXPECT_FALSE(fred.Get(IS_UNSYNCED));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_TRUE(fred.Get(PARENT_ID) == bob.Get(ID));
     EXPECT_TRUE(bob.Get(PARENT_ID) == root_id_);
     EXPECT_FALSE(fred.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
   }
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, NewServerItemInAFolderHierarchyWeHaveDeleted) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(2, 1, "joe", 1, 10);
   LoopSyncShare();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(IS_DEL, true);
     MutableEntry joe(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(joe.good());
     joe.Put(IS_UNSYNCED, true);
     joe.Put(IS_DEL, true);
   }
   mock_server_->AddUpdateDirectory(3, 2, "fred", 2, 20);
   mock_server_->set_conflict_all_commits(true);
   LoopSyncShare();
   LoopSyncShare();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     Entry joe(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(joe.good());
     Entry fred(&trans, GET_BY_ID, ids_.FromNumber(3));
     ASSERT_TRUE(fred.good());
     EXPECT_FALSE(fred.Get(IS_UNSYNCED));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_TRUE(joe.Get(IS_UNSYNCED));
     EXPECT_TRUE(fred.Get(PARENT_ID) == joe.Get(ID));
     EXPECT_TRUE(joe.Get(PARENT_ID) == bob.Get(ID));
     EXPECT_TRUE(bob.Get(PARENT_ID) == root_id_);
     EXPECT_FALSE(fred.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(joe.Get(IS_UNAPPLIED_UPDATE));
   }
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, NewServerItemInAFolderHierarchyWeHaveDeleted2) {
   // The difference here is that the hierarchy's not in the root. We have
   // another entry that shouldn't be touched.
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateDirectory(4, 0, "susan", 1, 10);
   mock_server_->AddUpdateDirectory(1, 4, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(2, 1, "joe", 1, 10);
   LoopSyncShare();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(IS_DEL, true);
     MutableEntry joe(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(joe.good());
     joe.Put(IS_UNSYNCED, true);
     joe.Put(IS_DEL, true);
   }
   mock_server_->AddUpdateDirectory(3, 2, "fred", 2, 20);
   mock_server_->set_conflict_all_commits(true);
   LoopSyncShare();
   LoopSyncShare();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     Entry joe(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(joe.good());
     Entry fred(&trans, GET_BY_ID, ids_.FromNumber(3));
     ASSERT_TRUE(fred.good());
     Entry susan(&trans, GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(susan.good());
     EXPECT_FALSE(susan.Get(IS_UNSYNCED));
     EXPECT_FALSE(fred.Get(IS_UNSYNCED));
@@ skipping 19 matching lines @@
   static const int64 susan_int_id_ = 4;
 
   void DeleteSusanInRoot() {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     ASSERT_TRUE(dir.good());
 
     const syncable::Id susan_id = TestIdFactory::FromNumber(susan_int_id_);
     ASSERT_GT(countdown_till_delete_, 0);
     if (0 != --countdown_till_delete_)
     return;
-  WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+  WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry susan(&trans, GET_BY_ID, susan_id);
   Directory::ChildHandles children;
   dir->GetChildHandlesById(&trans, susan.Get(ID), &children);
   ASSERT_TRUE(0 == children.size());
   susan.Put(IS_DEL, true);
   susan.Put(IS_UNSYNCED, true);
 }
 
  protected:
   int countdown_till_delete_;
@@ skipping 10 matching lines @@
   const syncable::Id joe_id = TestIdFactory::FromNumber(2);
   const syncable::Id fred_id = TestIdFactory::FromNumber(3);
   const syncable::Id susan_id = TestIdFactory::FromNumber(susan_int_id_);
 
   mock_server_->AddUpdateDirectory(susan_id, TestIdFactory::root(),
       "susan", 1, 10);
   mock_server_->AddUpdateDirectory(bob_id, susan_id, "bob", 1, 10);
   mock_server_->AddUpdateDirectory(joe_id, bob_id, "joe", 1, 10);
   LoopSyncShare();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(IS_DEL, true);
 
     MutableEntry joe(&trans, GET_BY_ID, joe_id);
     ASSERT_TRUE(joe.good());
     joe.Put(IS_UNSYNCED, true);
     joe.Put(IS_DEL, true);
   }
   mock_server_->AddUpdateDirectory(fred_id, joe_id, "fred", 2, 20);
   mock_server_->set_conflict_all_commits(true);
   countdown_till_delete_ = 2;
   syncer_->pre_conflict_resolution_closure_ =
       NewCallback<SusanDeletingTest>(this,
           &SusanDeletingTest::DeleteSusanInRoot);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     Entry joe(&trans, GET_BY_ID, joe_id);
     ASSERT_TRUE(joe.good());
     Entry fred(&trans, GET_BY_ID, fred_id);
     ASSERT_TRUE(fred.good());
     Entry susan(&trans, GET_BY_ID, susan_id);
     ASSERT_TRUE(susan.good());
     EXPECT_FALSE(susan.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(fred.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(joe.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(susan.Get(IS_UNSYNCED));
     EXPECT_FALSE(fred.Get(IS_UNSYNCED));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
     EXPECT_TRUE(joe.Get(IS_UNSYNCED));
   }
   EXPECT_TRUE(0 == countdown_till_delete_);
   delete syncer_->pre_conflict_resolution_closure_;
   syncer_->pre_conflict_resolution_closure_ = NULL;
   LoopSyncShare();
   LoopSyncShare();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     Entry joe(&trans, GET_BY_ID, joe_id);
     ASSERT_TRUE(joe.good());
     Entry fred(&trans, GET_BY_ID, fred_id);
     ASSERT_TRUE(fred.good());
     Entry susan(&trans, GET_BY_ID, susan_id);
     ASSERT_TRUE(susan.good());
     EXPECT_TRUE(susan.Get(IS_UNSYNCED));
     EXPECT_FALSE(fred.Get(IS_UNSYNCED));
@@ skipping 19 matching lines @@
   const syncable::Id fred_id = ids_.NewServerId();
   const syncable::Id alice_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 1, 10);
   mock_server_->AddUpdateDirectory(alice_id, fred_id, "alice", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, alice_id);  // Move into alice.
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->AddUpdateDirectory(alice_id, TestIdFactory::root(),
       "alice", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
     // Bob is the entry at the bottom of the tree.
     // The tree should be regenerated and old IDs removed.
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));
 
     // Old one should be deleted, but new one should have been made.
     Entry dead_alice(&trans, GET_BY_ID, alice_id);
     EXPECT_FALSE(dead_alice.good());
     EXPECT_NE(bob.Get(PARENT_ID), alice_id);
 
@@ skipping 33 matching lines @@
   const syncable::Id susan_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(bob_id, TestIdFactory::root(),
       "bob", 1, 10);
   mock_server_->AddUpdateDirectory(susan_id, TestIdFactory::root(),
       "susan", 1, 10);
   mock_server_->AddUpdateDirectory(fred_id, susan_id, "fred", 1, 10);
   mock_server_->AddUpdateDirectory(alice_id, fred_id, "alice", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     bob.Put(IS_UNSYNCED, true);
     bob.Put(PARENT_ID, alice_id);  // Move into alice.
   }
   mock_server_->AddUpdateDirectory(fred_id, TestIdFactory::root(),
       "fred", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->AddUpdateDirectory(alice_id, TestIdFactory::root(),
       "alice", 2, 20);
   mock_server_->SetLastUpdateDeleted();
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
   {
     // Root
     //   |- Susan
     //        |- Fred
     //            |- Alice
     //                 |- Bob
 
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry bob(&trans, GET_BY_ID, bob_id);
     ASSERT_TRUE(bob.good());
     EXPECT_FALSE(bob.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(bob.Get(IS_UNSYNCED));  // Parent changed
     EXPECT_NE(bob.Get(PARENT_ID), alice_id);
 
     // New one was born, this is the old one
     Entry dead_alice(&trans, GET_BY_ID, alice_id);
     EXPECT_FALSE(dead_alice.good());
 
@@ skipping 24 matching lines @@
   }
   saw_syncer_event_ = false;
 }
 
 // This test is to reproduce a check failure. Sometimes we would get a bad ID
 // back when creating an entry.
 TEST_F(SyncerTest, DuplicateIDReturn) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry folder(&trans, CREATE, trans.root_id(), "bob");
     ASSERT_TRUE(folder.good());
     folder.Put(IS_UNSYNCED, true);
     folder.Put(IS_DIR, true);
     folder.Put(SPECIFICS, DefaultBookmarkSpecifics());
     MutableEntry folder2(&trans, CREATE, trans.root_id(), "fred");
     ASSERT_TRUE(folder2.good());
     folder2.Put(IS_UNSYNCED, false);
     folder2.Put(IS_DIR, true);
     folder2.Put(SPECIFICS, DefaultBookmarkSpecifics());
     folder2.Put(BASE_VERSION, 3);
     folder2.Put(ID, syncable::Id::CreateFromServerId("mock_server:10000"));
   }
   mock_server_->set_next_new_id(10000);
   EXPECT_TRUE(1 == dir->unsynced_entity_count());
   // we get back a bad id in here (should never happen).
   SyncShareAsDelegate();
   EXPECT_TRUE(1 == dir->unsynced_entity_count());
   SyncShareAsDelegate();  // another bad id in here.
   EXPECT_TRUE(0 == dir->unsynced_entity_count());
   saw_syncer_event_ = false;
 }
 
 TEST_F(SyncerTest, DeletedEntryWithBadParentInLoopCalculation) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry bob(&trans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(bob.good());
     // This is valid, because the parent could have gone away a long time ago.
     bob.Put(PARENT_ID, ids_.FromNumber(54));
     bob.Put(IS_DEL, true);
     bob.Put(IS_UNSYNCED, true);
   }
   mock_server_->AddUpdateDirectory(2, 1, "fred", 1, 10);
   SyncShareAsDelegate();
   SyncShareAsDelegate();
 }
 
 TEST_F(SyncerTest, ConflictResolverMergeOverwritesLocalEntry) {
   // This test would die because it would rename a entry to a name that was
   // taken in the namespace
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   ConflictSet conflict_set;
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
 
     MutableEntry local_deleted(&trans, CREATE, trans.root_id(), "name");
     local_deleted.Put(ID, ids_.FromNumber(1));
     local_deleted.Put(BASE_VERSION, 1);
     local_deleted.Put(IS_DEL, true);
     local_deleted.Put(IS_UNSYNCED, true);
 
     MutableEntry in_the_way(&trans, CREATE, trans.root_id(), "name");
     in_the_way.Put(ID, ids_.FromNumber(2));
     in_the_way.Put(BASE_VERSION, 1);
 
     MutableEntry update(&trans, CREATE_NEW_UPDATE_ITEM, ids_.FromNumber(3));
     update.Put(BASE_VERSION, 1);
     update.Put(SERVER_NON_UNIQUE_NAME, "name");
     update.Put(PARENT_ID, ids_.FromNumber(0));
     update.Put(IS_UNAPPLIED_UPDATE, true);
 
     conflict_set.push_back(ids_.FromNumber(1));
     conflict_set.push_back(ids_.FromNumber(3));
   }
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     context_->resolver()->ProcessConflictSet(&trans, &conflict_set, 50);
   }
 }
 
 TEST_F(SyncerTest, ConflictResolverMergesLocalDeleteAndServerUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
 
     MutableEntry local_deleted(&trans, CREATE, trans.root_id(), "name");
     local_deleted.Put(ID, ids_.FromNumber(1));
     local_deleted.Put(BASE_VERSION, 1);
     local_deleted.Put(IS_DEL, true);
     local_deleted.Put(IS_DIR, false);
     local_deleted.Put(IS_UNSYNCED, true);
     local_deleted.Put(SPECIFICS, DefaultBookmarkSpecifics());
   }
 
   mock_server_->AddUpdateBookmark(ids_.FromNumber(1), root_id_, "name", 10, 10);
 
   // We don't care about actually committing, just the resolution.
   mock_server_->set_conflict_all_commits(true);
   SyncShareAsDelegate();
 
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry local_deleted(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_TRUE(local_deleted.Get(BASE_VERSION) == 10);
     EXPECT_TRUE(local_deleted.Get(IS_UNAPPLIED_UPDATE) == false);
     EXPECT_TRUE(local_deleted.Get(IS_UNSYNCED) == true);
     EXPECT_TRUE(local_deleted.Get(IS_DEL) == true);
     EXPECT_TRUE(local_deleted.Get(IS_DIR) == false);
   }
 }
 
 // See what happens if the IS_DIR bit gets flipped.  This can cause us
 // all kinds of disasters.
 TEST_F(SyncerTest, UpdateFlipsTheFolderBit) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   // Local object: a deleted directory (container), revision 1, unsynced.
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
 
     MutableEntry local_deleted(&trans, CREATE, trans.root_id(), "name");
     local_deleted.Put(ID, ids_.FromNumber(1));
     local_deleted.Put(BASE_VERSION, 1);
     local_deleted.Put(IS_DEL, true);
     local_deleted.Put(IS_DIR, true);
     local_deleted.Put(IS_UNSYNCED, true);
     local_deleted.Put(SPECIFICS, DefaultBookmarkSpecifics());
   }
 
   // Server update: entry-type object (not a container), revision 10.
   mock_server_->AddUpdateBookmark(ids_.FromNumber(1), root_id_, "name", 10, 10);
 
   // Don't attempt to commit.
   mock_server_->set_conflict_all_commits(true);
 
   // The syncer should not attempt to apply the invalid update.
   SyncShareAsDelegate();
 
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry local_deleted(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_TRUE(local_deleted.Get(BASE_VERSION) == 1);
     EXPECT_TRUE(local_deleted.Get(IS_UNAPPLIED_UPDATE) == false);
     EXPECT_TRUE(local_deleted.Get(IS_UNSYNCED) == true);
     EXPECT_TRUE(local_deleted.Get(IS_DEL) == true);
     EXPECT_TRUE(local_deleted.Get(IS_DIR) == true);
   }
 }
 
 TEST(SyncerSyncProcessState, MergeSetsTest) {
@@ skipping 32 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) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, CREATE, trans.root_id(), "Copy of base");
     WriteTestDataToEntry(&trans, &entry);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50);
   SyncRepeatedlyToTriggerConflictResolution(session_.get());
 }
 
 TEST_F(SyncerTest, OneBajillionUpdates) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
@@ skipping 35 matching lines @@
     mock_server_->NextUpdateBatch();
     mock_server_->SetNewTimestamp(i + 1);
     mock_server_->SetChangesRemaining(depth - i);
   }
 
   syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
   EXPECT_FALSE(session_->status_controller()->syncer_status().syncer_stuck);
 
   // Ensure our folder hasn't somehow applied.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry child(&trans, GET_BY_ID, stuck_entry_id);
     EXPECT_TRUE(child.good());
     EXPECT_TRUE(child.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(child.Get(IS_DEL));
     EXPECT_FALSE(child.Get(IS_UNSYNCED));
   }
 
   // And finally the folder.
   mock_server_->AddUpdateDirectory(folder_id,
       TestIdFactory::root(), "folder", 1, 1);
   mock_server_->SetChangesRemaining(0);
   LoopSyncShare();
   LoopSyncShare();
   // Check that everything is as expected after the commit.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_ID, folder_id);
     ASSERT_TRUE(entry.good());
     Entry child(&trans, GET_BY_ID, stuck_entry_id);
     EXPECT_EQ(entry.Get(ID), child.Get(PARENT_ID));
     EXPECT_EQ("stuck", child.Get(NON_UNIQUE_NAME));
     EXPECT_TRUE(child.good());
   }
 }
 
 TEST_F(SyncerTest, DontMergeTwoExistingItems) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(1, 0, "base", 10, 10);
   mock_server_->AddUpdateBookmark(2, 0, "base2", 10, 10);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Put(NON_UNIQUE_NAME, "Copy of base"));
     entry.Put(IS_UNSYNCED, true);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50);
   SyncRepeatedlyToTriggerConflictResolution(session_.get());
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry1(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_FALSE(entry1.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry1.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry1.Get(IS_DEL));
     Entry entry2(&trans, GET_BY_ID, ids_.FromNumber(2));
     EXPECT_FALSE(entry2.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(entry2.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry2.Get(IS_DEL));
     EXPECT_EQ(entry1.Get(NON_UNIQUE_NAME), entry2.Get(NON_UNIQUE_NAME));
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1);
   mock_server_->AddUpdateDirectory(2, 1, "bar", 1, 2);
   SyncShareAsDelegate();
   mock_server_->AddUpdateDirectory(2, 1, "bar", 2, 3);
   mock_server_->SetLastUpdateDeleted();
   SyncShareAsDelegate();
 
   int64 metahandle;
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Get(IS_DEL));
     metahandle = entry.Get(META_HANDLE);
   }
   mock_server_->AddUpdateDirectory(1, 0, "foo", 2, 4);
   mock_server_->SetLastUpdateDeleted();
   SyncShareAsDelegate();
   // This used to be rejected as it's an undeletion. Now, it results in moving
   // the delete path aside.
   mock_server_->AddUpdateDirectory(2, 1, "bar", 3, 5);
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Get(IS_DEL));
     EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
     EXPECT_TRUE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_NE(entry.Get(META_HANDLE), metahandle);
   }
 }
 
 TEST_F(SyncerTest, TestMoveSanitizedNamedFolder) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   mock_server_->AddUpdateDirectory(1, 0, "foo", 1, 1);
   mock_server_->AddUpdateDirectory(2, 0, ":::", 1, 2);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Put(PARENT_ID, ids_.FromNumber(1)));
     EXPECT_TRUE(entry.Put(IS_UNSYNCED, true));
   }
   SyncShareAsDelegate();
   // We use the same sync ts as before so our times match up.
   mock_server_->AddUpdateDirectory(2, 1, ":::", 2, 2);
   SyncShareAsDelegate();
 }
 
 // Don't crash when this occurs.
 TEST_F(SyncerTest, UpdateWhereParentIsNotAFolder) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   mock_server_->AddUpdateBookmark(1, 0, "B", 10, 10);
   mock_server_->AddUpdateDirectory(2, 1, "BookmarkParent", 10, 10);
   // Used to cause a CHECK
   SyncShareAsDelegate();
   {
-    ReadTransaction rtrans(dir, __FILE__, __LINE__);
+    ReadTransaction rtrans(dir, FROM_HERE);
     Entry good_entry(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(good_entry.good());
     EXPECT_FALSE(good_entry.Get(IS_UNAPPLIED_UPDATE));
     Entry bad_parent(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(bad_parent.good());
     EXPECT_TRUE(bad_parent.Get(IS_UNAPPLIED_UPDATE));
   }
 }
 
 const char kRootId[] = "0";
 
 TEST_F(SyncerTest, DirectoryUpdateTest) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   Id in_root_id = ids_.NewServerId();
   Id in_in_root_id = ids_.NewServerId();
 
   mock_server_->AddUpdateDirectory(in_root_id, TestIdFactory::root(),
                                    "in_root_name", 2, 2);
   mock_server_->AddUpdateDirectory(in_in_root_id, in_root_id,
                                    "in_in_root_name", 3, 3);
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry in_root(&trans, GET_BY_ID, in_root_id);
     ASSERT_TRUE(in_root.good());
     EXPECT_EQ("in_root_name", in_root.Get(NON_UNIQUE_NAME));
     EXPECT_EQ(TestIdFactory::root(), in_root.Get(PARENT_ID));
 
     Entry in_in_root(&trans, GET_BY_ID, in_in_root_id);
     ASSERT_TRUE(in_in_root.good());
     EXPECT_EQ("in_in_root_name", in_in_root.Get(NON_UNIQUE_NAME));
     EXPECT_EQ(in_root_id, in_in_root.Get(PARENT_ID));
   }
 }
 
 TEST_F(SyncerTest, DirectoryCommitTest) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   syncable::Id in_root_id, in_dir_id;
   int64 foo_metahandle;
   int64 bar_metahandle;
 
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry parent(&wtrans, syncable::CREATE, root_id_, "foo");
     ASSERT_TRUE(parent.good());
     parent.Put(syncable::IS_UNSYNCED, true);
     parent.Put(syncable::IS_DIR, true);
     parent.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     in_root_id = parent.Get(syncable::ID);
     foo_metahandle = parent.Get(META_HANDLE);
 
     MutableEntry child(&wtrans, syncable::CREATE, parent.Get(ID), "bar");
     ASSERT_TRUE(child.good());
     child.Put(syncable::IS_UNSYNCED, true);
     child.Put(syncable::IS_DIR, true);
     child.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
     bar_metahandle = child.Get(META_HANDLE);
     in_dir_id = parent.Get(syncable::ID);
   }
   SyncShareAsDelegate();
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry fail_by_old_id_entry(&trans, GET_BY_ID, in_root_id);
     ASSERT_FALSE(fail_by_old_id_entry.good());
 
     Entry foo_entry(&trans, GET_BY_HANDLE, foo_metahandle);
     ASSERT_TRUE(foo_entry.good());
     EXPECT_EQ("foo", foo_entry.Get(NON_UNIQUE_NAME));
     EXPECT_NE(foo_entry.Get(syncable::ID), in_root_id);
 
     Entry bar_entry(&trans, GET_BY_HANDLE, bar_metahandle);
     ASSERT_TRUE(bar_entry.good());
     EXPECT_EQ("bar", bar_entry.Get(NON_UNIQUE_NAME));
     EXPECT_NE(bar_entry.Get(syncable::ID), in_dir_id);
     EXPECT_EQ(foo_entry.Get(syncable::ID), bar_entry.Get(PARENT_ID));
   }
 }
 
 TEST_F(SyncerTest, ConflictSetSizeReducedToOne) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
 
   syncable::Id in_root_id = ids_.NewServerId();
 
   mock_server_->AddUpdateBookmark(in_root_id, TestIdFactory::root(),
       "in_root", 1, 1);
   SyncShareAsDelegate();
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry oentry(&trans, GET_BY_ID, in_root_id);
     ASSERT_TRUE(oentry.good());
     oentry.Put(NON_UNIQUE_NAME, "old_in_root");
     WriteTestDataToEntry(&trans, &oentry);
     MutableEntry entry(&trans, CREATE, trans.root_id(), "in_root");
     ASSERT_TRUE(entry.good());
     WriteTestDataToEntry(&trans, &entry);
   }
   mock_server_->set_conflict_all_commits(true);
   // This SyncShare call used to result in a CHECK failure.
@@ skipping 36 matching lines @@
   syncable::Id folder_one_id = ids_.FromNumber(1);
   syncable::Id folder_two_id = ids_.FromNumber(2);
 
   mock_server_->AddUpdateDirectory(folder_one_id, TestIdFactory::root(),
       "folder_one", 1, 1);
   mock_server_->AddUpdateDirectory(folder_two_id, TestIdFactory::root(),
       "folder_two", 1, 1);
   SyncShareAsDelegate();
   {
     // A moved entry should send an "old parent."
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, GET_BY_ID, folder_one_id);
     ASSERT_TRUE(entry.good());
     entry.Put(PARENT_ID, folder_two_id);
     entry.Put(IS_UNSYNCED, true);
     // A new entry should send no "old parent."
     MutableEntry create(&trans, CREATE, trans.root_id(), "new_folder");
     create.Put(IS_UNSYNCED, true);
     create.Put(SPECIFICS, DefaultBookmarkSpecifics());
   }
   SyncShareAsDelegate();
   const sync_pb::CommitMessage& commit = mock_server_->last_sent_commit();
   ASSERT_TRUE(2 == commit.entries_size());
   EXPECT_TRUE(commit.entries(0).parent_id_string() == "2");
   EXPECT_TRUE(commit.entries(0).old_parent_id() == "0");
   EXPECT_FALSE(commit.entries(1).has_old_parent_id());
 }
 
 TEST_F(SyncerTest, Test64BitVersionSupport) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   CHECK(dir.good());
   int64 really_big_int = std::numeric_limits<int64>::max() - 12;
   const string name("ringo's dang orang ran rings around my o-ring");
   int64 item_metahandle;
 
   // Try writing max int64 to the version fields of a meta entry.
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&wtrans, syncable::CREATE, wtrans.root_id(), name);
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::BASE_VERSION, really_big_int);
     entry.Put(syncable::SERVER_VERSION, really_big_int);
     entry.Put(syncable::ID, ids_.NewServerId());
     item_metahandle = entry.Get(META_HANDLE);
   }
   // Now read it back out and make sure the value is max int64.
-  ReadTransaction rtrans(dir, __FILE__, __LINE__);
+  ReadTransaction rtrans(dir, FROM_HERE);
   Entry entry(&rtrans, syncable::GET_BY_HANDLE, item_metahandle);
   ASSERT_TRUE(entry.good());
   EXPECT_TRUE(really_big_int == entry.Get(syncable::BASE_VERSION));
 }
 
 TEST_F(SyncerTest, TestSimpleUndelete) {
   Id id = ids_.MakeServer("undeletion item"), root = TestIdFactory::root();
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   mock_server_->set_conflict_all_commits(true);
   // Let there be an entry from the server.
   mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10);
   SyncShareAsDelegate();
   // Check it out and delete it.
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&wtrans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry.Get(IS_DEL));
     // Delete it locally.
     entry.Put(IS_DEL, true);
   }
   SyncShareAsDelegate();
   // Confirm we see IS_DEL and not SERVER_IS_DEL.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_TRUE(entry.Get(IS_DEL));
     EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
   }
   SyncShareAsDelegate();
   // Update from server confirming deletion.
   mock_server_->AddUpdateBookmark(id, root, "foo", 2, 11);
   mock_server_->SetLastUpdateDeleted();
   SyncShareAsDelegate();
   // IS_DEL AND SERVER_IS_DEL now both true.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_TRUE(entry.Get(IS_DEL));
     EXPECT_TRUE(entry.Get(SERVER_IS_DEL));
   }
   // Undelete from server.
   mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12);
   SyncShareAsDelegate();
   // IS_DEL and SERVER_IS_DEL now both false.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry.Get(IS_DEL));
     EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteWithMissingDeleteUpdate) {
   Id id = ids_.MakeServer("undeletion item"), root = TestIdFactory::root();
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   // Let there be a entry, from the server.
   mock_server_->set_conflict_all_commits(true);
   mock_server_->AddUpdateBookmark(id, root, "foo", 1, 10);
   SyncShareAsDelegate();
   // Check it out and delete it.
   {
-    WriteTransaction wtrans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction wtrans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&wtrans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry.Get(IS_DEL));
     // Delete it locally.
     entry.Put(IS_DEL, true);
   }
   SyncShareAsDelegate();
   // Confirm we see IS_DEL and not SERVER_IS_DEL.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_TRUE(entry.Get(IS_DEL));
     EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
   }
   SyncShareAsDelegate();
   // Say we do not get an update from server confirming deletion. Undelete
   // from server
   mock_server_->AddUpdateBookmark(id, root, "foo", 2, 12);
   SyncShareAsDelegate();
   // IS_DEL and SERVER_IS_DEL now both false.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_ID, id);
     ASSERT_TRUE(entry.good());
     EXPECT_FALSE(entry.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry.Get(IS_DEL));
     EXPECT_FALSE(entry.Get(SERVER_IS_DEL));
   }
 }
 
 TEST_F(SyncerTest, TestUndeleteIgnoreCorrectlyUnappliedUpdate) {
@@ skipping 13 matching lines @@
 TEST_F(SyncerTest, ClientTagServerCreatedUpdatesWork) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
 
   mock_server_->AddUpdateDirectory(1, 0, "permitem1", 1, 10);
   mock_server_->SetLastUpdateClientTag("permfolder");
 
   SyncShareAsDelegate();
 
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
     ASSERT_TRUE(perm_folder.good());
     EXPECT_FALSE(perm_folder.Get(IS_DEL));
     EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(perm_folder.Get(IS_UNSYNCED));
     EXPECT_EQ(perm_folder.Get(UNIQUE_CLIENT_TAG), "permfolder");
     EXPECT_EQ(perm_folder.Get(NON_UNIQUE_NAME), "permitem1");
   }
 
   mock_server_->AddUpdateDirectory(1, 0, "permitem_renamed", 10, 100);
   mock_server_->SetLastUpdateClientTag("permfolder");
   SyncShareAsDelegate();
 
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
     ASSERT_TRUE(perm_folder.good());
     EXPECT_FALSE(perm_folder.Get(IS_DEL));
     EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(perm_folder.Get(IS_UNSYNCED));
     EXPECT_EQ(perm_folder.Get(UNIQUE_CLIENT_TAG), "permfolder");
     EXPECT_EQ(perm_folder.Get(NON_UNIQUE_NAME), "permitem_renamed");
   }
 }
 
 TEST_F(SyncerTest, ClientTagIllegalUpdateIgnored) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
 
   mock_server_->AddUpdateDirectory(1, 0, "permitem1", 1, 10);
   mock_server_->SetLastUpdateClientTag("permfolder");
 
   SyncShareAsDelegate();
 
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
     ASSERT_TRUE(perm_folder.good());
     EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(perm_folder.Get(IS_UNSYNCED));
     EXPECT_EQ(perm_folder.Get(UNIQUE_CLIENT_TAG), "permfolder");
     EXPECT_TRUE(perm_folder.Get(NON_UNIQUE_NAME) == "permitem1");
     EXPECT_TRUE(perm_folder.Get(ID).ServerKnows());
   }
 
   mock_server_->AddUpdateDirectory(1, 0, "permitem_renamed", 10, 100);
   mock_server_->SetLastUpdateClientTag("wrongtag");
   SyncShareAsDelegate();
 
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     // This update is rejected because it has the same ID, but a
     // different tag than one that is already on the client.
     // The client has a ServerKnows ID, which cannot be overwritten.
     Entry rejected_update(&trans, GET_BY_CLIENT_TAG, "wrongtag");
     EXPECT_FALSE(rejected_update.good());
 
     Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "permfolder");
     ASSERT_TRUE(perm_folder.good());
     EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(perm_folder.Get(IS_UNSYNCED));
     EXPECT_EQ(perm_folder.Get(NON_UNIQUE_NAME), "permitem1");
   }
 }
 
 TEST_F(SyncerTest, ClientTagUncommittedTagMatchesUpdate) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   int64 original_metahandle = 0;
 
   sync_pb::EntitySpecifics local_bookmark(DefaultBookmarkSpecifics());
   local_bookmark.MutableExtension(sync_pb::bookmark)->
       set_url("http://foo/localsite");
   sync_pb::EntitySpecifics server_bookmark(DefaultBookmarkSpecifics());
   server_bookmark.MutableExtension(sync_pb::bookmark)->
       set_url("http://bar/serversite");
 
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry perm_folder(&trans, CREATE, ids_.root(), "clientname");
     ASSERT_TRUE(perm_folder.good());
     perm_folder.Put(UNIQUE_CLIENT_TAG, "clientperm");
     perm_folder.Put(SPECIFICS, local_bookmark);
     perm_folder.Put(IS_UNSYNCED, true);
     EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(perm_folder.Get(ID).ServerKnows());
     original_metahandle = perm_folder.Get(META_HANDLE);
   }
 
   mock_server_->AddUpdateBookmark(1, 0, "permitem_renamed", 10, 100);
   mock_server_->SetLastUpdateClientTag("clientperm");
   mock_server_->GetMutableLastUpdate()->mutable_specifics()->
       CopyFrom(server_bookmark);
   mock_server_->set_conflict_all_commits(true);
 
   SyncShareAsDelegate();
   // This should cause client tag reunion, preserving the metahandle.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "clientperm");
     ASSERT_TRUE(perm_folder.good());
     EXPECT_FALSE(perm_folder.Get(IS_DEL));
     EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(perm_folder.Get(IS_UNSYNCED));
     EXPECT_EQ(10, perm_folder.Get(BASE_VERSION));
     // Entry should have been given the new ID while preserving the
     // metahandle; client should have won the conflict resolution.
     EXPECT_EQ(original_metahandle, perm_folder.Get(META_HANDLE));
     EXPECT_EQ("clientperm", perm_folder.Get(UNIQUE_CLIENT_TAG));
     EXPECT_EQ("clientname", perm_folder.Get(NON_UNIQUE_NAME));
     EXPECT_EQ(local_bookmark.SerializeAsString(),
               perm_folder.Get(SPECIFICS).SerializeAsString());
     EXPECT_TRUE(perm_folder.Get(ID).ServerKnows());
   }
 
   mock_server_->set_conflict_all_commits(false);
   SyncShareAsDelegate();
 
   // The resolved entry ought to commit cleanly.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "clientperm");
     ASSERT_TRUE(perm_folder.good());
     EXPECT_FALSE(perm_folder.Get(IS_DEL));
     EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(perm_folder.Get(IS_UNSYNCED));
     EXPECT_TRUE(10 < perm_folder.Get(BASE_VERSION));
     // Entry should have been given the new ID while preserving the
     // metahandle; client should have won the conflict resolution.
     EXPECT_EQ(original_metahandle, perm_folder.Get(META_HANDLE));
     EXPECT_EQ("clientperm", perm_folder.Get(UNIQUE_CLIENT_TAG));
     EXPECT_EQ("clientname", perm_folder.Get(NON_UNIQUE_NAME));
     EXPECT_EQ(local_bookmark.SerializeAsString(),
               perm_folder.Get(SPECIFICS).SerializeAsString());
     EXPECT_TRUE(perm_folder.Get(ID).ServerKnows());
   }
 }
 
 TEST_F(SyncerTest, ClientTagConflictWithDeletedLocalEntry) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
 
   {
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry perm_folder(&trans, CREATE, ids_.root(), "clientname");
     ASSERT_TRUE(perm_folder.good());
     ASSERT_FALSE(perm_folder.Get(ID).ServerKnows());
     perm_folder.Put(UNIQUE_CLIENT_TAG, "clientperm");
     perm_folder.Put(SPECIFICS, DefaultBookmarkSpecifics());
     perm_folder.Put(IS_UNSYNCED, true);
     perm_folder.Put(IS_DEL, true);
   }
 
   mock_server_->AddUpdateDirectory(1, 0, "permitem_renamed", 10, 100);
   mock_server_->SetLastUpdateClientTag("clientperm");
   mock_server_->set_conflict_all_commits(true);
 
   SyncShareAsDelegate();
   // This should cause client tag overwrite.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry perm_folder(&trans, GET_BY_CLIENT_TAG, "clientperm");
     ASSERT_TRUE(perm_folder.good());
     ASSERT_TRUE(perm_folder.Get(ID).ServerKnows());
     EXPECT_TRUE(perm_folder.Get(IS_DEL));
     EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(perm_folder.Get(IS_UNSYNCED));
     EXPECT_EQ(perm_folder.Get(BASE_VERSION), 10);
     EXPECT_EQ(perm_folder.Get(UNIQUE_CLIENT_TAG), "clientperm");
   }
@@ skipping 13 matching lines @@
   mock_server_->AddUpdateBookmark(4, 0, "Four", 11, 110);
   mock_server_->SetLastUpdateClientTag("tag2");
 
   mock_server_->set_conflict_all_commits(true);
 
   SyncShareAsDelegate();
   int64 tag1_metahandle = syncable::kInvalidMetaHandle;
   int64 tag2_metahandle = syncable::kInvalidMetaHandle;
   // This should cause client tag overwrite.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry tag1(&trans, GET_BY_CLIENT_TAG, "tag1");
     ASSERT_TRUE(tag1.good());
     ASSERT_TRUE(tag1.Get(ID).ServerKnows());
     ASSERT_TRUE(ids_.FromNumber(1) == tag1.Get(ID));
     EXPECT_FALSE(tag1.Get(IS_DEL));
     EXPECT_FALSE(tag1.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(tag1.Get(IS_UNSYNCED));
     EXPECT_EQ("One", tag1.Get(NON_UNIQUE_NAME));
     EXPECT_EQ(10, tag1.Get(BASE_VERSION));
@@ skipping 17 matching lines @@
     ASSERT_EQ(2U, children.size());
   }
 
   mock_server_->AddUpdateBookmark(2, 0, "Two", 12, 120);
   mock_server_->SetLastUpdateClientTag("tag1");
   mock_server_->AddUpdateBookmark(3, 0, "Three", 13, 130);
   mock_server_->SetLastUpdateClientTag("tag2");
   SyncShareAsDelegate();
 
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry tag1(&trans, GET_BY_CLIENT_TAG, "tag1");
     ASSERT_TRUE(tag1.good());
     ASSERT_TRUE(tag1.Get(ID).ServerKnows());
     ASSERT_TRUE(ids_.FromNumber(1) == tag1.Get(ID))
         << "ID 1 should be kept, since it was less than ID 2.";
     EXPECT_FALSE(tag1.Get(IS_DEL));
     EXPECT_FALSE(tag1.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(tag1.Get(IS_UNSYNCED));
     EXPECT_EQ(10, tag1.Get(BASE_VERSION));
@@ skipping 54 matching lines @@
   mock_server_->AddUpdateBookmark(204, 0, "Three C", 20, 200);
   mock_server_->SetLastUpdateClientTag("tag c");
   mock_server_->AddUpdateBookmark(201, 0, "Four C", 21, 210);
   mock_server_->SetLastUpdateClientTag("tag c");  // Least ID: winner.
 
   mock_server_->set_conflict_all_commits(true);
 
   SyncShareAsDelegate();
   // This should cause client tag overwrite.
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Entry tag_a(&trans, GET_BY_CLIENT_TAG, "tag a");
     ASSERT_TRUE(tag_a.good());
     EXPECT_TRUE(tag_a.Get(ID).ServerKnows());
     EXPECT_EQ(ids_.FromNumber(1), tag_a.Get(ID));
     EXPECT_FALSE(tag_a.Get(IS_DEL));
     EXPECT_FALSE(tag_a.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(tag_a.Get(IS_UNSYNCED));
     EXPECT_EQ("One A", tag_a.Get(NON_UNIQUE_NAME));
     EXPECT_EQ(1, tag_a.Get(BASE_VERSION));
@@ skipping 27 matching lines @@
   }
 }
 
 TEST_F(SyncerTest, UniqueServerTagUpdates) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   EXPECT_TRUE(dir.good());
   // As a hurdle, introduce an item whose name is the same as the tag value
   // we'll use later.
   int64 hurdle_handle = CreateUnsyncedDirectory("bob", "id_bob");
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry hurdle(&trans, GET_BY_HANDLE, hurdle_handle);
     ASSERT_TRUE(hurdle.good());
     ASSERT_TRUE(!hurdle.Get(IS_DEL));
     ASSERT_TRUE(hurdle.Get(UNIQUE_SERVER_TAG).empty());
     ASSERT_TRUE(hurdle.Get(NON_UNIQUE_NAME) == "bob");
 
     // Try to lookup by the tagname.  These should fail.
     Entry tag_alpha(&trans, GET_BY_SERVER_TAG, "alpha");
     EXPECT_FALSE(tag_alpha.good());
     Entry tag_bob(&trans, GET_BY_SERVER_TAG, "bob");
     EXPECT_FALSE(tag_bob.good());
   }
 
   // Now download some tagged items as updates.
   mock_server_->AddUpdateDirectory(1, 0, "update1", 1, 10);
   mock_server_->SetLastUpdateServerTag("alpha");
   mock_server_->AddUpdateDirectory(2, 0, "update2", 2, 20);
   mock_server_->SetLastUpdateServerTag("bob");
   SyncShareAsDelegate();
 
   {
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     // The new items should be applied as new entries, and we should be able
     // to look them up by their tag values.
     Entry tag_alpha(&trans, GET_BY_SERVER_TAG, "alpha");
     ASSERT_TRUE(tag_alpha.good());
     ASSERT_TRUE(!tag_alpha.Get(IS_DEL));
     ASSERT_TRUE(tag_alpha.Get(UNIQUE_SERVER_TAG) == "alpha");
     ASSERT_TRUE(tag_alpha.Get(NON_UNIQUE_NAME) == "update1");
     Entry tag_bob(&trans, GET_BY_SERVER_TAG, "bob");
     ASSERT_TRUE(tag_bob.good());
@@ skipping 61 matching lines @@
 class SyncerUndeletionTest : public SyncerTest {
  public:
   SyncerUndeletionTest()
       : client_tag_("foobar"),
         metahandle_(syncable::kInvalidMetaHandle) {
   }
 
   void Create() {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     EXPECT_TRUE(dir.good());
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry perm_folder(&trans, CREATE, ids_.root(), "clientname");
     ASSERT_TRUE(perm_folder.good());
     perm_folder.Put(UNIQUE_CLIENT_TAG, client_tag_);
     perm_folder.Put(IS_UNSYNCED, true);
     perm_folder.Put(SYNCING, false);
     perm_folder.Put(SPECIFICS, DefaultBookmarkSpecifics());
     EXPECT_FALSE(perm_folder.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(perm_folder.Get(ID).ServerKnows());
     metahandle_ = perm_folder.Get(META_HANDLE);
   }
 
   void Delete() {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     EXPECT_TRUE(dir.good());
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, GET_BY_CLIENT_TAG, client_tag_);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(metahandle_, entry.Get(META_HANDLE));
     entry.Put(IS_DEL, true);
     entry.Put(IS_UNSYNCED, true);
     entry.Put(SYNCING, false);
   }
 
   void Undelete() {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     EXPECT_TRUE(dir.good());
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, GET_BY_CLIENT_TAG, client_tag_);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(metahandle_, entry.Get(META_HANDLE));
     EXPECT_TRUE(entry.Get(IS_DEL));
     entry.Put(IS_DEL, false);
     entry.Put(IS_UNSYNCED, true);
     entry.Put(SYNCING, false);
   }
 
   int64 GetMetahandleOfTag() {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     EXPECT_TRUE(dir.good());
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Entry entry(&trans, GET_BY_CLIENT_TAG, client_tag_);
     EXPECT_TRUE(entry.good());
     if (!entry.good()) {
       return syncable::kInvalidMetaHandle;
     }
     return entry.Get(META_HANDLE);
   }
 
   void ExpectUnsyncedCreation() {
     EXPECT_EQ(metahandle_, GetMetahandleOfTag());
@@ skipping 388 matching lines @@
  public:
   SyncerPositionUpdateTest() : next_update_id_(1), next_revision_(1) {}
 
  protected:
   void ExpectLocalItemsInServerOrder() {
     if (position_map_.empty())
       return;
 
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     EXPECT_TRUE(dir.good());
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
 
     Id prev_id;
     DCHECK(prev_id.IsRoot());
     PosMap::iterator next = position_map_.begin();
     for (PosMap::iterator i = next++; i != position_map_.end(); ++i) {
       Id id = i->second;
       Entry entry_with_id(&trans, GET_BY_ID, id);
       EXPECT_TRUE(entry_with_id.good());
       EXPECT_EQ(prev_id, entry_with_id.Get(PREV_ID));
       EXPECT_EQ(i->first, entry_with_id.Get(SERVER_POSITION_IN_PARENT));
@@ skipping 107 matching lines @@
     int revision = next_revision_++;
     mock_server_->AddUpdateDirectory(id.GetServerId(), kRootId,
         id.GetServerId(), revision, revision);
     // The update position doesn't vary.
     mock_server_->SetLastUpdatePosition(90210);
   }
 
   void ExpectLocalOrderIsByServerId() {
     ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
     EXPECT_TRUE(dir.good());
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     Id null_id;
     Entry low(&trans, GET_BY_ID, low_id_);
     Entry mid(&trans, GET_BY_ID, mid_id_);
     Entry high(&trans, GET_BY_ID, high_id_);
     EXPECT_TRUE(low.good());
     EXPECT_TRUE(mid.good());
     EXPECT_TRUE(high.good());
     EXPECT_TRUE(low.Get(PREV_ID) == null_id);
     EXPECT_TRUE(mid.Get(PREV_ID) == low_id_);
     EXPECT_TRUE(high.Get(PREV_ID) == mid_id_);
@@ skipping 60 matching lines @@
   Add(low_id_);
   Add(high_id_);
   SyncShareAsDelegate();
   ExpectLocalOrderIsByServerId();
 }
 
 const SyncerTest::CommitOrderingTest
 SyncerTest::CommitOrderingTest::LAST_COMMIT_ITEM = {-1, TestIdFactory::root()};
 
 }  // namespace browser_sync