sync: Add interfaces for per-type sync

sync/engine/directory_update_handler_unittest.cc

 // Copyright 2013 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 "sync/engine/sync_directory_update_handler.h"
+#include "sync/engine/directory_update_handler.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/test/test_entry_factory.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/directory.h"
@@ skipping 11 matching lines @@
 
 namespace syncer {
 
 using syncable::UNITTEST;
 
 // A test harness for tests that focus on processing updates.
 //
 // Update processing is what occurs when we first download updates.  It converts
 // the received protobuf message into information in the syncable::Directory.
 // Any invalid or redundant updates will be dropped at this point.
-class SyncDirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test {
+class DirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test {
  public:
-  SyncDirectoryUpdateHandlerProcessUpdateTest()
+  DirectoryUpdateHandlerProcessUpdateTest()
       : ui_worker_(new FakeModelWorker(GROUP_UI)) {
   }
 
-  virtual ~SyncDirectoryUpdateHandlerProcessUpdateTest() {}
+  virtual ~DirectoryUpdateHandlerProcessUpdateTest() {}
 
   virtual void SetUp() OVERRIDE {
     dir_maker_.SetUp();
   }
 
   virtual void TearDown() OVERRIDE {
     dir_maker_.TearDown();
   }
 
   syncable::Directory* dir() {
     return dir_maker_.directory();
   }
  protected:
   scoped_ptr<sync_pb::SyncEntity> CreateUpdate(
       const std::string& id,
       const std::string& parent,
       const ModelType& type);
 
   // This exists mostly to give tests access to the protected member function.
   // Warning: This takes the syncable directory lock.
   void UpdateSyncEntities(
-      SyncDirectoryUpdateHandler* handler,
+      DirectoryUpdateHandler* handler,
       const SyncEntityList& applicable_updates,
       sessions::StatusController* status);
 
   // Another function to access private member functions.
   void UpdateProgressMarkers(
-      SyncDirectoryUpdateHandler* handler,
+      DirectoryUpdateHandler* handler,
       const sync_pb::DataTypeProgressMarker& progress);
 
   scoped_refptr<FakeModelWorker> ui_worker() {
     return ui_worker_;
   }
 
  private:
   base::MessageLoop loop_;  // Needed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
   scoped_refptr<FakeModelWorker> ui_worker_;
 };
 
 scoped_ptr<sync_pb::SyncEntity>
-SyncDirectoryUpdateHandlerProcessUpdateTest::CreateUpdate(
+DirectoryUpdateHandlerProcessUpdateTest::CreateUpdate(
     const std::string& id,
     const std::string& parent,
     const ModelType& type) {
   scoped_ptr<sync_pb::SyncEntity> e(new sync_pb::SyncEntity());
   e->set_id_string(id);
   e->set_parent_id_string(parent);
   e->set_non_unique_name(id);
   e->set_name(id);
   e->set_version(1000);
   AddDefaultFieldValue(type, e->mutable_specifics());
   return e.Pass();
 }
 
-void SyncDirectoryUpdateHandlerProcessUpdateTest::UpdateSyncEntities(
-    SyncDirectoryUpdateHandler* handler,
+void DirectoryUpdateHandlerProcessUpdateTest::UpdateSyncEntities(
+    DirectoryUpdateHandler* handler,
     const SyncEntityList& applicable_updates,
     sessions::StatusController* status) {
   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, UNITTEST, dir());
   handler->UpdateSyncEntities(&trans, applicable_updates, status);
 }
 
-void SyncDirectoryUpdateHandlerProcessUpdateTest::UpdateProgressMarkers(
-    SyncDirectoryUpdateHandler* handler,
+void DirectoryUpdateHandlerProcessUpdateTest::UpdateProgressMarkers(
+    DirectoryUpdateHandler* handler,
     const sync_pb::DataTypeProgressMarker& progress) {
   handler->UpdateProgressMarker(progress);
 }
 
 static const char kCacheGuid[] = "IrcjZ2jyzHDV9Io4+zKcXQ==";
 
 // Test that the bookmark tag is set on newly downloaded items.
-TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) {
-  SyncDirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
+TEST_F(DirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) {
+  DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   // Add a bookmark item to the update message.
   std::string root = syncable::GetNullId().GetServerId();
   syncable::Id server_id = syncable::Id::CreateFromServerId("b1");
   scoped_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
   e->set_originator_cache_guid(
       std::string(kCacheGuid, arraysize(kCacheGuid)-1));
@@ skipping 15 matching lines @@
   EXPECT_TRUE(entry.GetServerUniquePosition().IsValid());
 
   // If this assertion fails, that might indicate that the algorithm used to
   // generate bookmark tags has been modified.  This could have implications for
   // bookmark ordering.  Please make sure you know what you're doing if you
   // intend to make such a change.
   EXPECT_EQ("6wHRAb3kbnXV5GHrejp4/c1y5tw=", entry.GetUniqueBookmarkTag());
 }
 
 // Test the receipt of a type root node.
-TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest,
+TEST_F(DirectoryUpdateHandlerProcessUpdateTest,
        ReceiveServerCreatedBookmarkFolders) {
-  SyncDirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
+  DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   // Create an update that mimics the bookmark root.
   syncable::Id server_id = syncable::Id::CreateFromServerId("xyz");
   std::string root = syncable::GetNullId().GetServerId();
   scoped_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
   e->set_server_defined_unique_tag("google_chrome_bookmarks");
   e->set_folder(true);
@@ skipping 12 matching lines @@
   syncable::Entry entry(&trans, syncable::GET_BY_ID, server_id);
   ASSERT_TRUE(entry.good());
 
   EXPECT_FALSE(entry.ShouldMaintainPosition());
   EXPECT_FALSE(entry.GetUniquePosition().IsValid());
   EXPECT_FALSE(entry.GetServerUniquePosition().IsValid());
   EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty());
 }
 
 // Test the receipt of a non-bookmark item.
-TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) {
-  SyncDirectoryUpdateHandler handler(dir(), PREFERENCES, ui_worker());
+TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) {
+  DirectoryUpdateHandler handler(dir(), PREFERENCES, ui_worker());
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   std::string root = syncable::GetNullId().GetServerId();
   syncable::Id server_id = syncable::Id::CreateFromServerId("xyz");
   scoped_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, PREFERENCES);
   e->set_server_defined_unique_tag("9PGRuKdX5sHyGMB17CvYTXuC43I=");
 
   // Add it to the applicable updates list.
   SyncEntityList autofill_updates;
   autofill_updates.push_back(e.get());
 
   EXPECT_FALSE(SyncerProtoUtil::ShouldMaintainPosition(*e));
 
   // Process it.
   UpdateSyncEntities(&handler, autofill_updates, &status);
 
   syncable::ReadTransaction trans(FROM_HERE, dir());
   syncable::Entry entry(&trans, syncable::GET_BY_ID, server_id);
   ASSERT_TRUE(entry.good());
 
   EXPECT_FALSE(entry.ShouldMaintainPosition());
   EXPECT_FALSE(entry.GetUniquePosition().IsValid());
   EXPECT_FALSE(entry.GetServerUniquePosition().IsValid());
   EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty());
 }
 
 // Tests the setting of progress markers.
-TEST_F(SyncDirectoryUpdateHandlerProcessUpdateTest, ProcessNewProgressMarkers) {
-  SyncDirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
+TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ProcessNewProgressMarkers) {
+  DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
 
   sync_pb::DataTypeProgressMarker progress;
   progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   progress.set_token("token");
 
   UpdateProgressMarkers(&handler, progress);
 
   sync_pb::DataTypeProgressMarker saved;
   dir()->GetDownloadProgress(BOOKMARKS, &saved);
 
   EXPECT_EQ(progress.token(), saved.token());
   EXPECT_EQ(progress.data_type_id(), saved.data_type_id());
 }
 
 // A test harness for tests that focus on applying updates.
 //
 // Update application is performed when we want to take updates that were
 // previously downloaded, processed, and stored in our syncable::Directory
 // and use them to update our local state (both the Directory's local state
 // and the model's local state, though these tests focus only on the Directory's
 // local state).
 //
 // This is kept separate from the update processing test in part for historical
 // reasons, and in part because these tests may require a bit more infrastrcture
 // in the future.  Update application should happen on a different thread a lot
 // of the time so these tests may end up requiring more infrastructure than the
 // update processing tests.  Currently, we're bypassing most of those issues by
 // using FakeModelWorkers, so there's not much difference between the two test
 // harnesses.
-class SyncDirectoryUpdateHandlerApplyUpdateTest : public ::testing::Test {
+class DirectoryUpdateHandlerApplyUpdateTest : public ::testing::Test {
  public:
-  SyncDirectoryUpdateHandlerApplyUpdateTest()
+  DirectoryUpdateHandlerApplyUpdateTest()
       : ui_worker_(new FakeModelWorker(GROUP_UI)),
         password_worker_(new FakeModelWorker(GROUP_PASSWORD)),
         passive_worker_(new FakeModelWorker(GROUP_PASSIVE)),
         update_handler_map_deleter_(&update_handler_map_) {}
 
   virtual void SetUp() OVERRIDE {
     dir_maker_.SetUp();
     entry_factory_.reset(new TestEntryFactory(directory()));
 
     update_handler_map_.insert(std::make_pair(
         BOOKMARKS,
-        new SyncDirectoryUpdateHandler(directory(), BOOKMARKS, ui_worker_)));
+        new DirectoryUpdateHandler(directory(), BOOKMARKS, ui_worker_)));
     update_handler_map_.insert(std::make_pair(
         PASSWORDS,
-        new SyncDirectoryUpdateHandler(directory(),
+        new DirectoryUpdateHandler(directory(),
                                        PASSWORDS,
                                        password_worker_)));
   }
 
   virtual void TearDown() OVERRIDE {
     dir_maker_.TearDown();
   }
 
  protected:
   void ApplyBookmarkUpdates(sessions::StatusController* status) {
     update_handler_map_[BOOKMARKS]->ApplyUpdates(status);
   }
 
   void ApplyPasswordUpdates(sessions::StatusController* status) {
     update_handler_map_[PASSWORDS]->ApplyUpdates(status);
   }
 
   TestEntryFactory* entry_factory() {
     return entry_factory_.get();
   }
 
   syncable::Directory* directory() {
     return dir_maker_.directory();
   }
 
  private:
-  typedef std::map<ModelType, SyncDirectoryUpdateHandler*> UpdateHandlerMap;
+  typedef std::map<ModelType, UpdateHandler*> UpdateHandlerMap;
 
   base::MessageLoop loop_;  // Needed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
   scoped_ptr<TestEntryFactory> entry_factory_;
 
   scoped_refptr<FakeModelWorker> ui_worker_;
   scoped_refptr<FakeModelWorker> password_worker_;
   scoped_refptr<FakeModelWorker> passive_worker_;
 
   UpdateHandlerMap update_handler_map_;
   STLValueDeleter<UpdateHandlerMap> update_handler_map_deleter_;
 };
 
 namespace {
 sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
   sync_pb::EntitySpecifics result;
   AddDefaultFieldValue(BOOKMARKS, &result);
   return result;
 }
 } // namespace
 
 // Test update application for a few bookmark items.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) {
   sessions::StatusController status;
 
   std::string root_server_id = syncable::GetNullId().GetServerId();
   int64 parent_handle =
       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
           "parent", DefaultBookmarkSpecifics(), root_server_id);
   int64 child_handle =
       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
           "child", DefaultBookmarkSpecifics(), "parent");
 
@@ skipping 16 matching lines @@
     ASSERT_TRUE(child.good());
 
     EXPECT_FALSE(parent.GetIsUnsynced());
     EXPECT_FALSE(parent.GetIsUnappliedUpdate());
     EXPECT_FALSE(child.GetIsUnsynced());
     EXPECT_FALSE(child.GetIsUnappliedUpdate());
   }
 }
 
 // Test that the applicator can handle updates delivered out of order.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        BookmarkChildrenBeforeParent) {
   // Start with some bookmarks whose parents are unknown.
   std::string root_server_id = syncable::GetNullId().GetServerId();
   int64 a_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "a_child_created_first", DefaultBookmarkSpecifics(), "parent");
   int64 x_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
       "x_child_created_first", DefaultBookmarkSpecifics(), "parent");
 
   // Update application will fail.
   sessions::StatusController status1;
@@ skipping 37 matching lines @@
     ASSERT_TRUE(a.good());
     ASSERT_TRUE(x.good());
 
     EXPECT_FALSE(a.GetIsUnappliedUpdate());
     EXPECT_FALSE(x.GetIsUnappliedUpdate());
   }
 }
 
 // Try to apply changes on an item that is both IS_UNSYNCED and
 // IS_UNAPPLIED_UPDATE.  Conflict resolution should be performed.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, SimpleBookmarkConflict) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmarkConflict) {
   int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem("x");
 
   int original_server_version = -10;
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     original_server_version = e.GetServerVersion();
     ASSERT_NE(original_server_version, e.GetBaseVersion());
     EXPECT_TRUE(e.GetIsUnsynced());
   }
@@ skipping 15 matching lines @@
 
     // The unsynced flag will remain set until we successfully commit the item.
     EXPECT_TRUE(e.GetIsUnsynced());
   }
 }
 
 // Create a simple conflict that is also a hierarchy conflict.  If we were to
 // follow the normal "server wins" logic, we'd end up violating hierarchy
 // constraints.  The hierarchy conflict must take precedence.  We can not allow
 // the update to be applied.  The item must remain in the conflict state.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, HierarchyAndSimpleConflict) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, HierarchyAndSimpleConflict) {
   // Create a simply-conflicting item.  It will start with valid parent ids.
   int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem(
       "orphaned_by_server");
   {
     // Manually set the SERVER_PARENT_ID to bad value.
     // A bad parent indicates a hierarchy conflict.
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
@@ skipping 10 matching lines @@
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(e.good());
     EXPECT_TRUE(e.GetIsUnappliedUpdate());
     EXPECT_TRUE(e.GetIsUnsynced());
   }
 }
 
 // Attempt to apply an udpate that would create a bookmark folder loop.  This
 // application should fail.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, BookmarkFolderLoop) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, BookmarkFolderLoop) {
   // Item 'X' locally has parent of 'root'.  Server is updating it to have
   // parent of 'Y'.
 
   // Create it as a child of root node.
   int64 handle = entry_factory()->CreateSyncedItem("X", BOOKMARKS, true);
 
   {
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
@@ skipping 24 matching lines @@
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(e.good());
     EXPECT_TRUE(e.GetIsUnappliedUpdate());
     EXPECT_FALSE(e.GetIsUnsynced());
   }
 }
 
 // Test update application where the update has been orphaned by a local folder
 // deletion.  The update application attempt should fail.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictDeletedParent) {
   // Create a locally deleted parent item.
   int64 parent_handle;
   entry_factory()->CreateUnsyncedItem(
       syncable::Id::CreateFromServerId("parent"), TestIdFactory::root(),
       "parent", true, BOOKMARKS, &parent_handle);
   {
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     syncable::MutableEntry entry(&trans,
                                  syncable::GET_BY_HANDLE,
@@ skipping 17 matching lines @@
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry child(&trans, syncable::GET_BY_HANDLE, child_handle);
     ASSERT_TRUE(child.good());
     EXPECT_TRUE(child.GetIsUnappliedUpdate());
     EXPECT_FALSE(child.GetIsUnsynced());
   }
 }
 
 // Attempt to apply an update that deletes a folder where the folder has
 // locally-created children.  The update application should fail.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictDeleteNonEmptyDirectory) {
   // Create a server-deleted folder as a child of root node.
   int64 parent_handle =
       entry_factory()->CreateSyncedItem("parent", BOOKMARKS, true);
   {
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     syncable::MutableEntry entry(&trans,
                                  syncable::GET_BY_HANDLE,
                                  parent_handle);
     ASSERT_TRUE(entry.good());
@@ skipping 23 matching lines @@
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry parent(&trans, syncable::GET_BY_HANDLE, parent_handle);
     ASSERT_TRUE(parent.good());
     EXPECT_TRUE(parent.GetIsUnappliedUpdate());
     EXPECT_FALSE(parent.GetIsUnsynced());
   }
 }
 
 // Attempt to apply updates where the updated item's parent is not known to this
 // client.  The update application attempt should fail.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest,
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictUnknownParent) {
   // We shouldn't be able to do anything with either of these items.
   int64 x_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "some_item", DefaultBookmarkSpecifics(), "unknown_parent");
   int64 y_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "some_other_item", DefaultBookmarkSpecifics(), "some_item");
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
 
@@ skipping 10 matching lines @@
     ASSERT_TRUE(y.good());
     EXPECT_TRUE(x.GetIsUnappliedUpdate());
     EXPECT_TRUE(y.GetIsUnappliedUpdate());
     EXPECT_FALSE(x.GetIsUnsynced());
     EXPECT_FALSE(y.GetIsUnsynced());
   }
 }
 
 // Attempt application of a mix of items.  Some update application attempts will
 // fail due to hierarchy conflicts.  Others should succeed.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, ItemsBothKnownAndUnknown) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, ItemsBothKnownAndUnknown) {
   // See what happens when there's a mixture of good and bad updates.
   std::string root_server_id = syncable::GetNullId().GetServerId();
   int64 u1_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "first_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
   int64 k1_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "first_known_item", DefaultBookmarkSpecifics(), root_server_id);
   int64 u2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "second_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
   int64 k2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "second_known_item", DefaultBookmarkSpecifics(), "first_known_item");
@@ skipping 27 matching lines @@
     EXPECT_TRUE(u1.GetIsUnappliedUpdate());
     EXPECT_TRUE(u2.GetIsUnappliedUpdate());
     EXPECT_FALSE(k1.GetIsUnappliedUpdate());
     EXPECT_FALSE(k2.GetIsUnappliedUpdate());
     EXPECT_FALSE(k3.GetIsUnappliedUpdate());
     EXPECT_FALSE(k4.GetIsUnappliedUpdate());
   }
 }
 
 // Attempt application of password upates where the passphrase is known.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, DecryptablePassword) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, DecryptablePassword) {
   // Decryptable password updates should be applied.
   Cryptographer* cryptographer;
   {
     // Storing the cryptographer separately is bad, but for this test we
     // know it's safe.
     syncable::ReadTransaction trans(FROM_HERE, directory());
     cryptographer = directory()->GetCryptographer(&trans);
   }
 
   KeyParams params = {"localhost", "dummy", "foobar"};
@@ skipping 17 matching lines @@
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(e.good());
     EXPECT_FALSE(e.GetIsUnappliedUpdate());
     EXPECT_FALSE(e.GetIsUnsynced());
   }
 }
 
 // Attempt application of encrypted items when the passphrase is not known.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, UndecryptableData) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, UndecryptableData) {
   // Undecryptable updates should not be applied.
   sync_pb::EntitySpecifics encrypted_bookmark;
   encrypted_bookmark.mutable_encrypted();
   AddDefaultFieldValue(BOOKMARKS, &encrypted_bookmark);
   std::string root_server_id = syncable::GetNullId().GetServerId();
   int64 folder_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "folder",
       encrypted_bookmark,
       root_server_id);
   int64 bookmark_handle = entry_factory()->CreateUnappliedNewItem(
@@ skipping 24 matching lines @@
     ASSERT_TRUE(folder.good());
     ASSERT_TRUE(bm.good());
     ASSERT_TRUE(pw.good());
     EXPECT_TRUE(folder.GetIsUnappliedUpdate());
     EXPECT_TRUE(bm.GetIsUnappliedUpdate());
     EXPECT_TRUE(pw.GetIsUnappliedUpdate());
   }
 }
 
 // Test a mix of decryptable and undecryptable updates.
-TEST_F(SyncDirectoryUpdateHandlerApplyUpdateTest, SomeUndecryptablePassword) {
+TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SomeUndecryptablePassword) {
   Cryptographer* cryptographer;
 
   int64 decryptable_handle = -1;
   int64 undecryptable_handle = -1;
 
   // Only decryptable password updates should be applied.
   {
     sync_pb::EntitySpecifics specifics;
     sync_pb::PasswordSpecificsData data;
     data.set_origin("http://example.com/1");
@@ skipping 40 matching lines @@
     syncable::Entry e1(&trans, syncable::GET_BY_HANDLE, decryptable_handle);
     syncable::Entry e2(&trans, syncable::GET_BY_HANDLE, undecryptable_handle);
     ASSERT_TRUE(e1.good());
     ASSERT_TRUE(e2.good());
     EXPECT_FALSE(e1.GetIsUnappliedUpdate());
     EXPECT_TRUE(e2.GetIsUnappliedUpdate());
   }
 }
 
 }  // namespace syncer