[Sync] rename USS processor / worker interfaces

sync/engine/commit_queue_impl_unittest.cc

Index: sync/engine/commit_queue_impl_unittest.cc
diff --git a/sync/engine/model_type_sync_worker_impl_unittest.cc b/sync/engine/commit_queue_impl_unittest.cc
similarity index 87%
rename from sync/engine/model_type_sync_worker_impl_unittest.cc
rename to sync/engine/commit_queue_impl_unittest.cc
index 0e58a98cdfafabbe6a160caa006764605bd4aae0..027baea7a21be49a065512d541f94d2ade6c1312 100644
--- a/sync/engine/model_type_sync_worker_impl_unittest.cc
+++ b/sync/engine/commit_queue_impl_unittest.cc
@@ -2,17 +2,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "sync/engine/model_type_sync_worker_impl.h"
+#include "sync/engine/commit_queue_impl.h"
 
 #include "base/strings/stringprintf.h"
 #include "sync/engine/commit_contribution.h"
-#include "sync/engine/model_type_sync_proxy.h"
+#include "sync/engine/model_type_processor.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/non_blocking_sync_common.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/syncable_util.h"
-#include "sync/test/engine/mock_model_type_sync_proxy.h"
+#include "sync/test/engine/mock_model_type_processor.h"
 #include "sync/test/engine/mock_nudge_handler.h"
 #include "sync/test/engine/single_type_mock_server.h"
 #include "sync/test/fake_encryptor.h"
@@ -32,7 +32,7 @@ using syncer::KeyParams;
 using syncer::Nigori;
 using syncer::sessions::StatusController;
 
-// Tests the ModelTypeSyncWorkerImpl.
+// Tests the CommitQueueImpl.
 //
 // This class passes messages between the model thread and sync server.
 // As such, its code is subject to lots of different race conditions.  This
@@ -52,17 +52,17 @@ using syncer::sessions::StatusController;
 // - Update responses to the model thread.
 // - Nudges to the sync scheduler.
 //
-// We use the MockModelTypeSyncProxy to stub out all communication
+// We use the MockModelTypeProcessor to stub out all communication
 // with the model thread.  That interface is synchronous, which makes it
 // much easier to test races.
 //
 // The interface with the server is built around "pulling" data from this
 // class, so we don't have to mock out any of it.  We wrap it with some
 // convenience functions to we can emulate server behavior.
-class ModelTypeSyncWorkerImplTest : public ::testing::Test {
+class CommitQueueImplTest : public ::testing::Test {
  public:
-  ModelTypeSyncWorkerImplTest();
-  ~ModelTypeSyncWorkerImplTest() override;
+  CommitQueueImplTest();
+  ~CommitQueueImplTest() override;
 
   // One of these Initialize functions should be called at the beginning of
   // each test.
@@ -174,7 +174,7 @@ class ModelTypeSyncWorkerImplTest : public ::testing::Test {
   int GetNumInitialDownloadNudges() const;
 
   // Returns the name of the encryption key in the cryptographer last passed to
-  // the ModelTypeSyncWorker.  Returns an empty string if no crypgorapher is
+  // the CommitQueue.  Returns an empty string if no crypgorapher is
   // in use.  See also: UpdateLocalCryptographer().
   std::string GetLocalCryptographerKeyName() const;
 
@@ -213,34 +213,34 @@ class ModelTypeSyncWorkerImplTest : public ::testing::Test {
   // value implies no encryption.
   int update_encryption_filter_index_;
 
-  // The ModelTypeSyncWorkerImpl being tested.
-  scoped_ptr<ModelTypeSyncWorkerImpl> worker_;
+  // The CommitQueueImpl being tested.
+  scoped_ptr<CommitQueueImpl> worker_;
 
   // Non-owned, possibly NULL pointer.  This object belongs to the
-  // ModelTypeSyncWorkerImpl under test.
-  MockModelTypeSyncProxy* mock_type_sync_proxy_;
+  // CommitQueueImpl under test.
+  MockModelTypeProcessor* mock_type_sync_proxy_;
 
   // A mock that emulates enough of the sync server that it can be used
   // a single UpdateHandler and CommitContributor pair.  In this test
   // harness, the |worker_| is both of them.
   syncer::SingleTypeMockServer mock_server_;
 
-  // A mock to track the number of times the ModelTypeSyncWorker requests to
+  // A mock to track the number of times the CommitQueue requests to
   // sync.
   syncer::MockNudgeHandler mock_nudge_handler_;
 };
 
-ModelTypeSyncWorkerImplTest::ModelTypeSyncWorkerImplTest()
+CommitQueueImplTest::CommitQueueImplTest()
     : foreign_encryption_key_index_(0),
       update_encryption_filter_index_(0),
       mock_type_sync_proxy_(NULL),
       mock_server_(kModelType) {
 }
 
-ModelTypeSyncWorkerImplTest::~ModelTypeSyncWorkerImplTest() {
+CommitQueueImplTest::~CommitQueueImplTest() {
 }
 
-void ModelTypeSyncWorkerImplTest::FirstInitialize() {
+void CommitQueueImplTest::FirstInitialize() {
   DataTypeState initial_state;
   initial_state.progress_marker.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(kModelType));
@@ -248,11 +248,11 @@ void ModelTypeSyncWorkerImplTest::FirstInitialize() {
   InitializeWithState(initial_state, UpdateResponseDataList());
 }
 
-void ModelTypeSyncWorkerImplTest::NormalInitialize() {
+void CommitQueueImplTest::NormalInitialize() {
   InitializeWithPendingUpdates(UpdateResponseDataList());
 }
 
-void ModelTypeSyncWorkerImplTest::InitializeWithPendingUpdates(
+void CommitQueueImplTest::InitializeWithPendingUpdates(
     const UpdateResponseDataList& initial_pending_updates) {
   DataTypeState initial_state;
   initial_state.progress_marker.set_data_type_id(
@@ -266,29 +266,29 @@ void ModelTypeSyncWorkerImplTest::InitializeWithPendingUpdates(
   mock_nudge_handler_.ClearCounters();
 }
 
-void ModelTypeSyncWorkerImplTest::InitializeWithState(
+void CommitQueueImplTest::InitializeWithState(
     const DataTypeState& state,
     const UpdateResponseDataList& initial_pending_updates) {
   DCHECK(!worker_);
 
   // We don't get to own this object.  The |worker_| keeps a scoped_ptr to it.
-  mock_type_sync_proxy_ = new MockModelTypeSyncProxy();
-  scoped_ptr<ModelTypeSyncProxy> proxy(mock_type_sync_proxy_);
+  mock_type_sync_proxy_ = new MockModelTypeProcessor();
+  scoped_ptr<ModelTypeProcessor> proxy(mock_type_sync_proxy_);
 
   scoped_ptr<Cryptographer> cryptographer_copy;
   if (cryptographer_) {
     cryptographer_copy.reset(new Cryptographer(*cryptographer_));
   }
 
-  worker_.reset(new ModelTypeSyncWorkerImpl(kModelType,
-                                            state,
-                                            initial_pending_updates,
-                                            cryptographer_copy.Pass(),
-                                            &mock_nudge_handler_,
-                                            proxy.Pass()));
+  worker_.reset(new CommitQueueImpl(kModelType,
+                                    state,
+                                    initial_pending_updates,
+                                    cryptographer_copy.Pass(),
+                                    &mock_nudge_handler_,
+                                    proxy.Pass()));
 }
 
-void ModelTypeSyncWorkerImplTest::NewForeignEncryptionKey() {
+void CommitQueueImplTest::NewForeignEncryptionKey() {
   if (!cryptographer_) {
     cryptographer_.reset(new Cryptographer(&fake_encryptor_));
   }
@@ -334,7 +334,7 @@ void ModelTypeSyncWorkerImplTest::NewForeignEncryptionKey() {
   }
 }
 
-void ModelTypeSyncWorkerImplTest::UpdateLocalCryptographer() {
+void CommitQueueImplTest::UpdateLocalCryptographer() {
   if (!cryptographer_) {
     cryptographer_.reset(new Cryptographer(&fake_encryptor_));
   }
@@ -350,11 +350,11 @@ void ModelTypeSyncWorkerImplTest::UpdateLocalCryptographer() {
   }
 }
 
-void ModelTypeSyncWorkerImplTest::SetUpdateEncryptionFilter(int n) {
+void CommitQueueImplTest::SetUpdateEncryptionFilter(int n) {
   update_encryption_filter_index_ = n;
 }
 
-void ModelTypeSyncWorkerImplTest::CommitRequest(const std::string& name,
+void CommitQueueImplTest::CommitRequest(const std::string& name,
                                                 const std::string& value) {
   const std::string tag_hash = GenerateTagHash(name);
   CommitRequestData data = mock_type_sync_proxy_->CommitRequest(
@@ -364,7 +364,7 @@ void ModelTypeSyncWorkerImplTest::CommitRequest(const std::string& name,
   worker_->EnqueueForCommit(list);
 }
 
-void ModelTypeSyncWorkerImplTest::DeleteRequest(const std::string& tag) {
+void CommitQueueImplTest::DeleteRequest(const std::string& tag) {
   const std::string tag_hash = GenerateTagHash(tag);
   CommitRequestData data = mock_type_sync_proxy_->DeleteRequest(tag_hash);
   CommitRequestDataList list;
@@ -372,7 +372,7 @@ void ModelTypeSyncWorkerImplTest::DeleteRequest(const std::string& tag) {
   worker_->EnqueueForCommit(list);
 }
 
-void ModelTypeSyncWorkerImplTest::TriggerTypeRootUpdateFromServer() {
+void CommitQueueImplTest::TriggerTypeRootUpdateFromServer() {
   sync_pb::SyncEntity entity = mock_server_.TypeRootUpdate();
   SyncEntityList entity_list;
   entity_list.push_back(&entity);
@@ -386,7 +386,7 @@ void ModelTypeSyncWorkerImplTest::TriggerTypeRootUpdateFromServer() {
   worker_->ApplyUpdates(&dummy_status);
 }
 
-void ModelTypeSyncWorkerImplTest::TriggerUpdateFromServer(
+void CommitQueueImplTest::TriggerUpdateFromServer(
     int64 version_offset,
     const std::string& tag,
     const std::string& value) {
@@ -410,7 +410,7 @@ void ModelTypeSyncWorkerImplTest::TriggerUpdateFromServer(
   worker_->ApplyUpdates(&dummy_status);
 }
 
-void ModelTypeSyncWorkerImplTest::DeliverRawUpdates(
+void CommitQueueImplTest::DeliverRawUpdates(
     const SyncEntityList& list) {
   StatusController dummy_status;
   worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
@@ -420,7 +420,7 @@ void ModelTypeSyncWorkerImplTest::DeliverRawUpdates(
   worker_->ApplyUpdates(&dummy_status);
 }
 
-void ModelTypeSyncWorkerImplTest::TriggerTombstoneFromServer(
+void CommitQueueImplTest::TriggerTombstoneFromServer(
     int64 version_offset,
     const std::string& tag) {
   sync_pb::SyncEntity entity =
@@ -443,16 +443,16 @@ void ModelTypeSyncWorkerImplTest::TriggerTombstoneFromServer(
   worker_->ApplyUpdates(&dummy_status);
 }
 
-void ModelTypeSyncWorkerImplTest::SetModelThreadIsSynchronous(
+void CommitQueueImplTest::SetModelThreadIsSynchronous(
     bool is_synchronous) {
   mock_type_sync_proxy_->SetSynchronousExecution(is_synchronous);
 }
 
-void ModelTypeSyncWorkerImplTest::PumpModelThread() {
+void CommitQueueImplTest::PumpModelThread() {
   mock_type_sync_proxy_->RunQueuedTasks();
 }
 
-bool ModelTypeSyncWorkerImplTest::WillCommit() {
+bool CommitQueueImplTest::WillCommit() {
   scoped_ptr<CommitContribution> contribution(
       worker_->GetContribution(INT_MAX));
 
@@ -468,7 +468,7 @@ bool ModelTypeSyncWorkerImplTest::WillCommit() {
 // remains blocked while the commit is in progress, so we don't need to worry
 // about other tasks being run between the time when the commit request is
 // issued and the time when the commit response is received.
-void ModelTypeSyncWorkerImplTest::DoSuccessfulCommit() {
+void CommitQueueImplTest::DoSuccessfulCommit() {
   DCHECK(WillCommit());
   scoped_ptr<CommitContribution> contribution(
       worker_->GetContribution(INT_MAX));
@@ -484,101 +484,101 @@ void ModelTypeSyncWorkerImplTest::DoSuccessfulCommit() {
   contribution->CleanUp();
 }
 
-size_t ModelTypeSyncWorkerImplTest::GetNumCommitMessagesOnServer() const {
+size_t CommitQueueImplTest::GetNumCommitMessagesOnServer() const {
   return mock_server_.GetNumCommitMessages();
 }
 
 sync_pb::ClientToServerMessage
-ModelTypeSyncWorkerImplTest::GetNthCommitMessageOnServer(size_t n) const {
+CommitQueueImplTest::GetNthCommitMessageOnServer(size_t n) const {
   DCHECK_LT(n, GetNumCommitMessagesOnServer());
   return mock_server_.GetNthCommitMessage(n);
 }
 
-bool ModelTypeSyncWorkerImplTest::HasCommitEntityOnServer(
+bool CommitQueueImplTest::HasCommitEntityOnServer(
     const std::string& tag) const {
   const std::string tag_hash = GenerateTagHash(tag);
   return mock_server_.HasCommitEntity(tag_hash);
 }
 
-sync_pb::SyncEntity ModelTypeSyncWorkerImplTest::GetLatestCommitEntityOnServer(
+sync_pb::SyncEntity CommitQueueImplTest::GetLatestCommitEntityOnServer(
     const std::string& tag) const {
   DCHECK(HasCommitEntityOnServer(tag));
   const std::string tag_hash = GenerateTagHash(tag);
   return mock_server_.GetLastCommittedEntity(tag_hash);
 }
 
-size_t ModelTypeSyncWorkerImplTest::GetNumModelThreadUpdateResponses() const {
+size_t CommitQueueImplTest::GetNumModelThreadUpdateResponses() const {
   return mock_type_sync_proxy_->GetNumUpdateResponses();
 }
 
 UpdateResponseDataList
-ModelTypeSyncWorkerImplTest::GetNthModelThreadUpdateResponse(size_t n) const {
+CommitQueueImplTest::GetNthModelThreadUpdateResponse(size_t n) const {
   DCHECK_LT(n, GetNumModelThreadUpdateResponses());
   return mock_type_sync_proxy_->GetNthUpdateResponse(n);
 }
 
 UpdateResponseDataList
-ModelTypeSyncWorkerImplTest::GetNthModelThreadPendingUpdates(size_t n) const {
+CommitQueueImplTest::GetNthModelThreadPendingUpdates(size_t n) const {
   DCHECK_LT(n, GetNumModelThreadUpdateResponses());
   return mock_type_sync_proxy_->GetNthPendingUpdates(n);
 }
 
-DataTypeState ModelTypeSyncWorkerImplTest::GetNthModelThreadUpdateState(
+DataTypeState CommitQueueImplTest::GetNthModelThreadUpdateState(
     size_t n) const {
   DCHECK_LT(n, GetNumModelThreadUpdateResponses());
   return mock_type_sync_proxy_->GetNthTypeStateReceivedInUpdateResponse(n);
 }
 
-bool ModelTypeSyncWorkerImplTest::HasUpdateResponseOnModelThread(
+bool CommitQueueImplTest::HasUpdateResponseOnModelThread(
     const std::string& tag) const {
   const std::string tag_hash = GenerateTagHash(tag);
   return mock_type_sync_proxy_->HasUpdateResponse(tag_hash);
 }
 
-UpdateResponseData ModelTypeSyncWorkerImplTest::GetUpdateResponseOnModelThread(
+UpdateResponseData CommitQueueImplTest::GetUpdateResponseOnModelThread(
     const std::string& tag) const {
   const std::string tag_hash = GenerateTagHash(tag);
   return mock_type_sync_proxy_->GetUpdateResponse(tag_hash);
 }
 
-size_t ModelTypeSyncWorkerImplTest::GetNumModelThreadCommitResponses() const {
+size_t CommitQueueImplTest::GetNumModelThreadCommitResponses() const {
   return mock_type_sync_proxy_->GetNumCommitResponses();
 }
 
 CommitResponseDataList
-ModelTypeSyncWorkerImplTest::GetNthModelThreadCommitResponse(size_t n) const {
+CommitQueueImplTest::GetNthModelThreadCommitResponse(size_t n) const {
   DCHECK_LT(n, GetNumModelThreadCommitResponses());
   return mock_type_sync_proxy_->GetNthCommitResponse(n);
 }
 
-DataTypeState ModelTypeSyncWorkerImplTest::GetNthModelThreadCommitState(
+DataTypeState CommitQueueImplTest::GetNthModelThreadCommitState(
     size_t n) const {
   DCHECK_LT(n, GetNumModelThreadCommitResponses());
   return mock_type_sync_proxy_->GetNthTypeStateReceivedInCommitResponse(n);
 }
 
-bool ModelTypeSyncWorkerImplTest::HasCommitResponseOnModelThread(
+bool CommitQueueImplTest::HasCommitResponseOnModelThread(
     const std::string& tag) const {
   const std::string tag_hash = GenerateTagHash(tag);
   return mock_type_sync_proxy_->HasCommitResponse(tag_hash);
 }
 
-CommitResponseData ModelTypeSyncWorkerImplTest::GetCommitResponseOnModelThread(
+CommitResponseData CommitQueueImplTest::GetCommitResponseOnModelThread(
     const std::string& tag) const {
   DCHECK(HasCommitResponseOnModelThread(tag));
   const std::string tag_hash = GenerateTagHash(tag);
   return mock_type_sync_proxy_->GetCommitResponse(tag_hash);
 }
 
-int ModelTypeSyncWorkerImplTest::GetNumCommitNudges() const {
+int CommitQueueImplTest::GetNumCommitNudges() const {
   return mock_nudge_handler_.GetNumCommitNudges();
 }
 
-int ModelTypeSyncWorkerImplTest::GetNumInitialDownloadNudges() const {
+int CommitQueueImplTest::GetNumInitialDownloadNudges() const {
   return mock_nudge_handler_.GetNumInitialDownloadNudges();
 }
 
-std::string ModelTypeSyncWorkerImplTest::GetLocalCryptographerKeyName() const {
+std::string CommitQueueImplTest::GetLocalCryptographerKeyName() const {
   if (!cryptographer_) {
     return std::string();
   }
@@ -587,7 +587,7 @@ std::string ModelTypeSyncWorkerImplTest::GetLocalCryptographerKeyName() const {
 }
 
 // static.
-std::string ModelTypeSyncWorkerImplTest::GenerateTagHash(
+std::string CommitQueueImplTest::GenerateTagHash(
     const std::string& tag) {
   const std::string& client_tag_hash =
       syncer::syncable::GenerateSyncableHash(kModelType, tag);
@@ -595,7 +595,7 @@ std::string ModelTypeSyncWorkerImplTest::GenerateTagHash(
 }
 
 // static.
-sync_pb::EntitySpecifics ModelTypeSyncWorkerImplTest::GenerateSpecifics(
+sync_pb::EntitySpecifics CommitQueueImplTest::GenerateSpecifics(
     const std::string& tag,
     const std::string& value) {
   sync_pb::EntitySpecifics specifics;
@@ -605,7 +605,7 @@ sync_pb::EntitySpecifics ModelTypeSyncWorkerImplTest::GenerateSpecifics(
 }
 
 // static.
-std::string ModelTypeSyncWorkerImplTest::GetNigoriName(const Nigori& nigori) {
+std::string CommitQueueImplTest::GetNigoriName(const Nigori& nigori) {
   std::string name;
   if (!nigori.Permute(Nigori::Password, kNigoriKeyName, &name)) {
     NOTREACHED();
@@ -616,7 +616,7 @@ std::string ModelTypeSyncWorkerImplTest::GetNigoriName(const Nigori& nigori) {
 }
 
 // static.
-KeyParams ModelTypeSyncWorkerImplTest::GetNthKeyParams(int n) {
+KeyParams CommitQueueImplTest::GetNthKeyParams(int n) {
   KeyParams params;
   params.hostname = std::string("localhost");
   params.username = std::string("userX");
@@ -625,7 +625,7 @@ KeyParams ModelTypeSyncWorkerImplTest::GetNthKeyParams(int n) {
 }
 
 // static.
-void ModelTypeSyncWorkerImplTest::EncryptUpdate(
+void CommitQueueImplTest::EncryptUpdate(
     const KeyParams& params,
     sync_pb::EntitySpecifics* specifics) {
   Nigori nigori;
@@ -652,7 +652,7 @@ void ModelTypeSyncWorkerImplTest::EncryptUpdate(
 // and the |worker_| doesn't mess up its simple task of moving around these
 // values.  It makes sense to have one or two tests that are this thorough, but
 // we shouldn't be this verbose in all tests.
-TEST_F(ModelTypeSyncWorkerImplTest, SimpleCommit) {
+TEST_F(CommitQueueImplTest, SimpleCommit) {
   NormalInitialize();
 
   EXPECT_FALSE(WillCommit());
@@ -698,7 +698,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, SimpleCommit) {
   EXPECT_LT(0, commit_response.response_version);
 }
 
-TEST_F(ModelTypeSyncWorkerImplTest, SimpleDelete) {
+TEST_F(CommitQueueImplTest, SimpleDelete) {
   NormalInitialize();
 
   // We can't delete an entity that was never committed.
@@ -747,7 +747,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, SimpleDelete) {
 
 // The server doesn't like it when we try to delete an entity it's never heard
 // of before.  This test helps ensure we avoid that scenario.
-TEST_F(ModelTypeSyncWorkerImplTest, NoDeleteUncommitted) {
+TEST_F(CommitQueueImplTest, NoDeleteUncommitted) {
   NormalInitialize();
 
   // Request the commit of a new, never-before-seen item.
@@ -762,7 +762,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, NoDeleteUncommitted) {
 }
 
 // Verifies the sending of an "initial sync done" signal.
-TEST_F(ModelTypeSyncWorkerImplTest, SendInitialSyncDone) {
+TEST_F(CommitQueueImplTest, SendInitialSyncDone) {
   FirstInitialize();  // Initialize with no saved sync state.
   EXPECT_EQ(0U, GetNumModelThreadUpdateResponses());
   EXPECT_EQ(1, GetNumInitialDownloadNudges());
@@ -786,7 +786,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, SendInitialSyncDone) {
 }
 
 // Commit two new entities in two separate commit messages.
-TEST_F(ModelTypeSyncWorkerImplTest, TwoNewItemsCommittedSeparately) {
+TEST_F(CommitQueueImplTest, TwoNewItemsCommittedSeparately) {
   NormalInitialize();
 
   // Commit the first of two entities.
@@ -826,7 +826,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, TwoNewItemsCommittedSeparately) {
 }
 
 // Test normal update receipt code path.
-TEST_F(ModelTypeSyncWorkerImplTest, ReceiveUpdates) {
+TEST_F(CommitQueueImplTest, ReceiveUpdates) {
   NormalInitialize();
 
   const std::string& tag_hash = GenerateTagHash("tag1");
@@ -852,7 +852,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, ReceiveUpdates) {
 }
 
 // Test commit of encrypted updates.
-TEST_F(ModelTypeSyncWorkerImplTest, EncryptedCommit) {
+TEST_F(CommitQueueImplTest, EncryptedCommit) {
   NormalInitialize();
 
   ASSERT_EQ(0U, GetNumModelThreadUpdateResponses());
@@ -885,7 +885,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, EncryptedCommit) {
 }
 
 // Test items are not committed when encryption is required but unavailable.
-TEST_F(ModelTypeSyncWorkerImplTest, EncryptionBlocksCommits) {
+TEST_F(CommitQueueImplTest, EncryptionBlocksCommits) {
   NormalInitialize();
 
   CommitRequest("tag1", "value1");
@@ -918,7 +918,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, EncryptionBlocksCommits) {
 }
 
 // Test the receipt of decryptable entities.
-TEST_F(ModelTypeSyncWorkerImplTest, ReceiveDecryptableEntities) {
+TEST_F(CommitQueueImplTest, ReceiveDecryptableEntities) {
   NormalInitialize();
 
   // Create a new Nigori and allow the cryptographer to decrypt it.
@@ -949,8 +949,8 @@ TEST_F(ModelTypeSyncWorkerImplTest, ReceiveDecryptableEntities) {
   EXPECT_FALSE(update2.encryption_key_name.empty());
 }
 
-// Test initializing a ModelTypeSyncWorker with a cryptographer at startup.
-TEST_F(ModelTypeSyncWorkerImplTest, InitializeWithCryptographer) {
+// Test initializing a CommitQueue with a cryptographer at startup.
+TEST_F(CommitQueueImplTest, InitializeWithCryptographer) {
   // Set up some encryption state.
   NewForeignEncryptionKey();
   UpdateLocalCryptographer();
@@ -968,7 +968,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, InitializeWithCryptographer) {
 
 // Receive updates that are initially undecryptable, then ensure they get
 // delivered to the model thread when decryption becomes possible.
-TEST_F(ModelTypeSyncWorkerImplTest, ReceiveUndecryptableEntries) {
+TEST_F(CommitQueueImplTest, ReceiveUndecryptableEntries) {
   NormalInitialize();
 
   // Receive a new foreign encryption key that we can't decrypt.
@@ -997,7 +997,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, ReceiveUndecryptableEntries) {
 }
 
 // Ensure that even encrypted updates can cause conflicts.
-TEST_F(ModelTypeSyncWorkerImplTest, EncryptedUpdateOverridesPendingCommit) {
+TEST_F(CommitQueueImplTest, EncryptedUpdateOverridesPendingCommit) {
   NormalInitialize();
 
   // Prepeare to commit an item.
@@ -1020,7 +1020,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, EncryptedUpdateOverridesPendingCommit) {
 }
 
 // Test decryption of pending updates saved across a restart.
-TEST_F(ModelTypeSyncWorkerImplTest, RestorePendingEntries) {
+TEST_F(CommitQueueImplTest, RestorePendingEntries) {
   // Create a fake pending update.
   UpdateResponseData update;
 
@@ -1035,7 +1035,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, RestorePendingEntries) {
   update.specifics = GenerateSpecifics("tag1", "value1");
   EncryptUpdate(GetNthKeyParams(1), &(update.specifics));
 
-  // Inject the update during ModelTypeSyncWorker initialization.
+  // Inject the update during CommitQueue initialization.
   UpdateResponseDataList saved_pending_updates;
   saved_pending_updates.push_back(update);
   InitializeWithPendingUpdates(saved_pending_updates);
@@ -1054,8 +1054,8 @@ TEST_F(ModelTypeSyncWorkerImplTest, RestorePendingEntries) {
 
 // Test decryption of pending updates saved across a restart.  This test
 // differs from the previous one in that the restored updates can be decrypted
-// immediately after the ModelTypeSyncWorker is constructed.
-TEST_F(ModelTypeSyncWorkerImplTest, RestoreApplicableEntries) {
+// immediately after the CommitQueue is constructed.
+TEST_F(CommitQueueImplTest, RestoreApplicableEntries) {
   // Update the cryptographer so it can decrypt that update.
   NewForeignEncryptionKey();
   UpdateLocalCryptographer();
@@ -1073,7 +1073,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, RestoreApplicableEntries) {
   update.specifics = GenerateSpecifics("tag1", "value1");
   EncryptUpdate(GetNthKeyParams(1), &(update.specifics));
 
-  // Inject the update during ModelTypeSyncWorker initialization.
+  // Inject the update during CommitQueue initialization.
   UpdateResponseDataList saved_pending_updates;
   saved_pending_updates.push_back(update);
   InitializeWithPendingUpdates(saved_pending_updates);
@@ -1087,7 +1087,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, RestoreApplicableEntries) {
 // This should be rare in practice.  Usually the cryptographer will be in an
 // unusable state when we receive undecryptable updates, and that alone will be
 // enough to prevent all commits.
-TEST_F(ModelTypeSyncWorkerImplTest, CommitBlockedByPending) {
+TEST_F(CommitQueueImplTest, CommitBlockedByPending) {
   NormalInitialize();
 
   // Prepeare to commit an item.
@@ -1111,7 +1111,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, CommitBlockedByPending) {
 }
 
 // Verify that corrupted encrypted updates don't cause crashes.
-TEST_F(ModelTypeSyncWorkerImplTest, ReceiveCorruptEncryption) {
+TEST_F(CommitQueueImplTest, ReceiveCorruptEncryption) {
   // Initialize the worker with basic encryption state.
   NormalInitialize();
   NewForeignEncryptionKey();