[Sync] Split DirectoryChangeListener for thread-safety

chrome/browser/sync/engine/process_commit_response_command_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
 #include <vector>
 
 #include "base/stringprintf.h"
+#include "base/tracked.h"
 #include "chrome/browser/sync/engine/mock_model_safe_workers.h"
 #include "chrome/browser/sync/engine/process_commit_response_command.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/syncable/syncable_id.h"
 #include "chrome/test/sync/engine/syncer_command_test.h"
 #include "chrome/test/sync/engine/test_id_factory.h"
@@ skipping 65 matching lines @@
   // fake the server data so that it looks like it exists on the server.
   // Returns the methandle of the created item in |metahandle_out| if not NULL.
   void CreateUnsyncedItem(const Id& item_id,
                           const Id& parent_id,
                           const string& name,
                           bool is_folder,
                           syncable::ModelType model_type,
                           int64* metahandle_out) {
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     Id predecessor_id = dir->GetLastChildId(&trans, parent_id);
     MutableEntry entry(&trans, syncable::CREATE, parent_id, name);
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::ID, item_id);
     entry.Put(syncable::BASE_VERSION,
         item_id.ServerKnows() ? next_old_revision_++ : 0);
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::IS_DIR, is_folder);
     entry.Put(syncable::IS_DEL, false);
     entry.Put(syncable::PARENT_ID, parent_id);
@@ skipping 25 matching lines @@
     CreateUnsyncedItem(item_id, parent_id, name, is_folder, model_type,
                        &metahandle);
 
     // ProcessCommitResponseCommand consumes commit_ids from the session
     // state, so we need to update that.  O(n^2) because it's a test.
     commit_set_->AddCommitItem(metahandle, item_id, model_type);
     sync_state->set_commit_set(*commit_set_.get());
 
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
-    WriteTransaction trans(dir, UNITTEST, __FILE__, __LINE__);
+    WriteTransaction trans(dir, UNITTEST, FROM_HERE);
     MutableEntry entry(&trans, syncable::GET_BY_ID, item_id);
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::SYNCING, true);
 
     // ProcessCommitResponseCommand looks at both the commit message as well
     // as the commit response, so we need to synthesize both here.
     sync_pb::ClientToServerMessage* commit =
         sync_state->mutable_commit_message();
     commit->set_message_contents(ClientToServerMessage::COMMIT);
     SyncEntity* entity = static_cast<SyncEntity*>(
@@ skipping 75 matching lines @@
                                 "Pref 2", syncable::PREFERENCES);
   CreateUnprocessedCommitResult(autofill_id1, id_factory_.root(),
                                 "Autofill 1", syncable::AUTOFILL);
   CreateUnprocessedCommitResult(autofill_id2, id_factory_.root(),
                                 "Autofill 2", syncable::AUTOFILL);
 
   command_.ExecuteImpl(session());
 
   ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
   ASSERT_TRUE(dir.good());
-  ReadTransaction trans(dir, __FILE__, __LINE__);
+  ReadTransaction trans(dir, FROM_HERE);
   Id new_fid = dir->GetFirstChildId(&trans, id_factory_.root());
   ASSERT_FALSE(new_fid.IsRoot());
   EXPECT_TRUE(new_fid.ServerKnows());
   EXPECT_FALSE(bookmark_folder_id.ServerKnows());
   EXPECT_FALSE(new_fid == bookmark_folder_id);
   Entry b_folder(&trans, syncable::GET_BY_ID, new_fid);
   ASSERT_TRUE(b_folder.good());
   ASSERT_EQ("A bookmark folder", b_folder.Get(NON_UNIQUE_NAME))
       << "Name of bookmark folder should not change.";
   ASSERT_LT(0, b_folder.Get(BASE_VERSION))
@@ skipping 33 matching lines @@
 TEST_F(ProcessCommitResponseCommandTest, NewFolderCommitKeepsChildOrder) {
   // Create the parent folder, a new item whose ID will change on commit.
   Id folder_id = id_factory_.NewLocalId();
   CreateUnprocessedCommitResult(folder_id, id_factory_.root(), "A",
                                 syncable::BOOKMARKS);
 
   // Verify that the item is reachable.
   {
     ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
     ASSERT_TRUE(dir.good());
-    ReadTransaction trans(dir, __FILE__, __LINE__);
+    ReadTransaction trans(dir, FROM_HERE);
     ASSERT_EQ(folder_id, dir->GetFirstChildId(&trans, id_factory_.root()));
   }
 
   // The first 25 children of the parent folder will be part of the commit
   // batch.
   int batch_size = 25;
   int i = 0;
   for (; i < batch_size; ++i) {
     // Alternate between new and old child items, just for kicks.
     Id id = (i % 4 < 2) ? id_factory_.NewLocalId() : id_factory_.NewServerId();
@@ skipping 12 matching lines @@
   }
 
   // Process the commit response for the parent folder and the first
   // 25 items.  This should apply the values indicated by
   // each CommitResponse_EntryResponse to the syncable Entries.  All new
   // items in the commit batch should have their IDs changed to server IDs.
   command_.ExecuteImpl(session());
 
   ScopedDirLookup dir(syncdb()->manager(), syncdb()->name());
   ASSERT_TRUE(dir.good());
-  ReadTransaction trans(dir, __FILE__, __LINE__);
+  ReadTransaction trans(dir, FROM_HERE);
   // Lookup the parent folder by finding a child of the root.  We can't use
   // folder_id here, because it changed during the commit.
   Id new_fid = dir->GetFirstChildId(&trans, id_factory_.root());
   ASSERT_FALSE(new_fid.IsRoot());
   EXPECT_TRUE(new_fid.ServerKnows());
   EXPECT_FALSE(folder_id.ServerKnows());
   EXPECT_TRUE(new_fid != folder_id);
   Entry parent(&trans, syncable::GET_BY_ID, new_fid);
   ASSERT_TRUE(parent.good());
   ASSERT_EQ("A", parent.Get(NON_UNIQUE_NAME))
@@ skipping 97 matching lines @@
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U,    final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 
 }  // namespace browser_sync