[Sync] rename USS processor / worker interfaces

sync/engine/commit_queue_impl_unittest.cc

 // Copyright 2014 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/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"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 static const syncer::ModelType kModelType = syncer::PREFERENCES;
 
 // Special constant value taken from cryptographer.cc.
 const char kNigoriKeyName[] = "nigori-key";
 
 namespace syncer_v2 {
 
 using syncer::Cryptographer;
 using syncer::CommitContribution;
 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
 // test harness lets us exhaustively test all possible races.  We try to
 // focus on just a few interesting cases.
 //
 // Inputs:
 // - Initial data type state from the model thread.
 // - Commit requests from the model thread.
 // - Update responses from the server.
 // - Commit responses from the server.
 // - The cryptographer, if encryption is enabled.
 //
 // Outputs:
 // - Commit requests to the server.
 // - Commit responses to the model thread.
 // - 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.
 
   // Initializes with no data type state.  We will be unable to perform any
   // significant server action until we receive an update response that
   // contains the type root node for this type.
   void FirstInitialize();
 
   // Initializes with some existing data type state.  Allows us to start
@@ skipping 91 matching lines @@
   CommitResponseData GetCommitResponseOnModelThread(
       const std::string& tag) const;
 
   // Returns the number of commit nudges sent to the mock nudge handler.
   int GetNumCommitNudges() const;
 
   // Returns the number of initial sync nudges sent to the mock nudge handler.
   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;
 
   // Helpers for building various messages and structures.
   static std::string GenerateTagHash(const std::string& tag);
   static sync_pb::EntitySpecifics GenerateSpecifics(const std::string& tag,
                                                     const std::string& value);
 
   // Returns a set of KeyParams for the cryptographer.  Each input 'n' value
   // results in a different set of parameters.
@@ skipping 18 matching lines @@
   scoped_ptr<Cryptographer> cryptographer_;
 
   // The number of the most recent foreign encryption key known to our
   // cryptographer.  Note that not all of these will be decryptable.
   int foreign_encryption_key_index_;
 
   // The number of the encryption key used to encrypt incoming updates.  A zero
   // 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));
 
   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(
       GetSpecificsFieldNumberFromModelType(kModelType));
   initial_state.progress_marker.set_token("some_saved_progress_token");
 
   initial_state.initial_sync_done = true;
 
   InitializeWithState(initial_state, initial_pending_updates);
 
   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_));
   }
 
   foreign_encryption_key_index_++;
 
   sync_pb::NigoriKeyBag bag;
 
   for (int i = 0; i <= foreign_encryption_key_index_; ++i) {
     Nigori nigori;
@@ skipping 25 matching lines @@
   // Update the cryptographer with new pending keys.
   cryptographer_->SetPendingKeys(encrypted);
 
   // Update the worker with the latest cryptographer.
   if (worker_) {
     worker_->UpdateCryptographer(
         make_scoped_ptr(new Cryptographer(*cryptographer_)));
   }
 }
 
-void ModelTypeSyncWorkerImplTest::UpdateLocalCryptographer() {
+void CommitQueueImplTest::UpdateLocalCryptographer() {
   if (!cryptographer_) {
     cryptographer_.reset(new Cryptographer(&fake_encryptor_));
   }
 
   KeyParams params = GetNthKeyParams(foreign_encryption_key_index_);
   bool success = cryptographer_->DecryptPendingKeys(params);
   DCHECK(success);
 
   // Update the worker with the latest cryptographer.
   if (worker_) {
     worker_->UpdateCryptographer(
         make_scoped_ptr(new Cryptographer(*cryptographer_)));
   }
 }
 
-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(
       tag_hash, GenerateSpecifics(name, value));
   CommitRequestDataList list;
   list.push_back(data);
   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;
   list.push_back(data);
   worker_->EnqueueForCommit(list);
 }
 
-void ModelTypeSyncWorkerImplTest::TriggerTypeRootUpdateFromServer() {
+void CommitQueueImplTest::TriggerTypeRootUpdateFromServer() {
   sync_pb::SyncEntity entity = mock_server_.TypeRootUpdate();
   SyncEntityList entity_list;
   entity_list.push_back(&entity);
 
   StatusController dummy_status;
 
   worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
                                      mock_server_.GetContext(),
                                      entity_list,
                                      &dummy_status);
   worker_->ApplyUpdates(&dummy_status);
 }
 
-void ModelTypeSyncWorkerImplTest::TriggerUpdateFromServer(
+void CommitQueueImplTest::TriggerUpdateFromServer(
     int64 version_offset,
     const std::string& tag,
     const std::string& value) {
   sync_pb::SyncEntity entity = mock_server_.UpdateFromServer(
       version_offset, GenerateTagHash(tag), GenerateSpecifics(tag, value));
 
   if (update_encryption_filter_index_ != 0) {
     EncryptUpdate(GetNthKeyParams(update_encryption_filter_index_),
                   entity.mutable_specifics());
   }
 
   SyncEntityList entity_list;
   entity_list.push_back(&entity);
 
   StatusController dummy_status;
 
   worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
                                      mock_server_.GetContext(),
                                      entity_list,
                                      &dummy_status);
   worker_->ApplyUpdates(&dummy_status);
 }
 
-void ModelTypeSyncWorkerImplTest::DeliverRawUpdates(
+void CommitQueueImplTest::DeliverRawUpdates(
     const SyncEntityList& list) {
   StatusController dummy_status;
   worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
                                      mock_server_.GetContext(),
                                      list,
                                      &dummy_status);
   worker_->ApplyUpdates(&dummy_status);
 }
 
-void ModelTypeSyncWorkerImplTest::TriggerTombstoneFromServer(
+void CommitQueueImplTest::TriggerTombstoneFromServer(
     int64 version_offset,
     const std::string& tag) {
   sync_pb::SyncEntity entity =
       mock_server_.TombstoneFromServer(version_offset, GenerateTagHash(tag));
 
   if (update_encryption_filter_index_ != 0) {
     EncryptUpdate(GetNthKeyParams(update_encryption_filter_index_),
                   entity.mutable_specifics());
   }
 
   SyncEntityList entity_list;
   entity_list.push_back(&entity);
 
   StatusController dummy_status;
 
   worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
                                      mock_server_.GetContext(),
                                      entity_list,
                                      &dummy_status);
   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));
 
   if (contribution) {
     contribution->CleanUp();  // Gracefully abort the commit.
     return true;
   } else {
     return false;
   }
 }
 
 // Conveniently, this is all one big synchronous operation.  The sync thread
 // 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));
 
   sync_pb::ClientToServerMessage message;
   contribution->AddToCommitMessage(&message);
 
   sync_pb::ClientToServerResponse response =
       mock_server_.DoSuccessfulCommit(message);
 
   StatusController dummy_status;
   contribution->ProcessCommitResponse(response, &dummy_status);
   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();
   }
 
   return cryptographer_->GetDefaultNigoriKeyName();
 }
 
 // static.
-std::string ModelTypeSyncWorkerImplTest::GenerateTagHash(
+std::string CommitQueueImplTest::GenerateTagHash(
     const std::string& tag) {
   const std::string& client_tag_hash =
       syncer::syncable::GenerateSyncableHash(kModelType, tag);
   return client_tag_hash;
 }
 
 // static.
-sync_pb::EntitySpecifics ModelTypeSyncWorkerImplTest::GenerateSpecifics(
+sync_pb::EntitySpecifics CommitQueueImplTest::GenerateSpecifics(
     const std::string& tag,
     const std::string& value) {
   sync_pb::EntitySpecifics specifics;
   specifics.mutable_preference()->set_name(tag);
   specifics.mutable_preference()->set_value(value);
   return specifics;
 }
 
 // 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();
     return std::string();
   }
 
   return name;
 }
 
 // static.
-KeyParams ModelTypeSyncWorkerImplTest::GetNthKeyParams(int n) {
+KeyParams CommitQueueImplTest::GetNthKeyParams(int n) {
   KeyParams params;
   params.hostname = std::string("localhost");
   params.username = std::string("userX");
   params.password = base::StringPrintf("pw%02d", n);
   return params;
 }
 
 // static.
-void ModelTypeSyncWorkerImplTest::EncryptUpdate(
+void CommitQueueImplTest::EncryptUpdate(
     const KeyParams& params,
     sync_pb::EntitySpecifics* specifics) {
   Nigori nigori;
   nigori.InitByDerivation(params.hostname, params.username, params.password);
 
   sync_pb::EntitySpecifics original_specifics = *specifics;
   std::string plaintext;
   original_specifics.SerializeToString(&plaintext);
 
   std::string encrypted;
   nigori.Encrypt(plaintext, &encrypted);
 
   specifics->Clear();
   AddDefaultFieldValue(kModelType, specifics);
   specifics->mutable_encrypted()->set_key_name(GetNigoriName(nigori));
   specifics->mutable_encrypted()->set_blob(encrypted);
 }
 
 // Requests a commit and verifies the messages sent to the client and server as
 // a result.
 //
 // This test performs sanity checks on most of the fields in these messages.
 // For the most part this is checking that the test code behaves as expected
 // 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());
   EXPECT_EQ(0U, GetNumCommitMessagesOnServer());
   EXPECT_EQ(0U, GetNumModelThreadCommitResponses());
 
   CommitRequest("tag1", "value1");
 
   EXPECT_EQ(1, GetNumCommitNudges());
 
@@ skipping 25 matching lines @@
       GetCommitResponseOnModelThread("tag1");
 
   // The ID changes in a commit response to initial commit.
   EXPECT_FALSE(commit_response.id.empty());
   EXPECT_NE(entity.id_string(), commit_response.id);
 
   EXPECT_EQ(client_tag_hash, commit_response.client_tag_hash);
   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.
   // Step 1 is to create and commit a new entity.
   CommitRequest("tag1", "value1");
   EXPECT_EQ(1, GetNumCommitNudges());
   ASSERT_TRUE(WillCommit());
   DoSuccessfulCommit();
 
   ASSERT_TRUE(HasCommitResponseOnModelThread("tag1"));
@@ skipping 28 matching lines @@
       GetCommitResponseOnModelThread("tag1");
 
   EXPECT_EQ(entity.id_string(), commit_response.id);
   EXPECT_EQ(entity.client_defined_unique_tag(),
             commit_response.client_tag_hash);
   EXPECT_EQ(entity.version(), commit_response.response_version);
 }
 
 // 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.
   CommitRequest("tag1", "value1");
   EXPECT_TRUE(WillCommit());
   EXPECT_EQ(1, GetNumCommitNudges());
 
   // Request a deletion of that item before we've had a chance to commit it.
   DeleteRequest("tag1");
   EXPECT_FALSE(WillCommit());
   EXPECT_EQ(2, GetNumCommitNudges());
 }
 
 // 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());
 
   // Receive an update response that contains only the type root node.
   TriggerTypeRootUpdateFromServer();
 
   // Two updates:
   // - One triggered by process updates to forward the type root ID.
   // - One triggered by apply updates, which the worker interprets to mean
   //   "initial sync done".  This triggers a model thread update, too.
   EXPECT_EQ(2U, GetNumModelThreadUpdateResponses());
 
   // The type root and initial sync done updates both contain no entities.
   EXPECT_EQ(0U, GetNthModelThreadUpdateResponse(0).size());
   EXPECT_EQ(0U, GetNthModelThreadUpdateResponse(1).size());
 
   const DataTypeState& state = GetNthModelThreadUpdateState(1);
   EXPECT_FALSE(state.progress_marker.token().empty());
   EXPECT_TRUE(state.initial_sync_done);
 }
 
 // Commit two new entities in two separate commit messages.
-TEST_F(ModelTypeSyncWorkerImplTest, TwoNewItemsCommittedSeparately) {
+TEST_F(CommitQueueImplTest, TwoNewItemsCommittedSeparately) {
   NormalInitialize();
 
   // Commit the first of two entities.
   CommitRequest("tag1", "value1");
   EXPECT_EQ(1, GetNumCommitNudges());
   ASSERT_TRUE(WillCommit());
   DoSuccessfulCommit();
   ASSERT_EQ(1U, GetNumCommitMessagesOnServer());
   EXPECT_EQ(1, GetNthCommitMessageOnServer(0).commit().entries_size());
   ASSERT_TRUE(HasCommitEntityOnServer("tag1"));
@@ skipping 19 matching lines @@
   // Check that the committed specifics values are sane.
   EXPECT_EQ(tag1_entity.specifics().preference().value(), "value1");
   EXPECT_EQ(tag2_entity.specifics().preference().value(), "value2");
 
   // There should have been two separate commit responses sent to the model
   // thread.  They should be uninteresting, so we don't bother inspecting them.
   EXPECT_EQ(2U, GetNumModelThreadCommitResponses());
 }
 
 // Test normal update receipt code path.
-TEST_F(ModelTypeSyncWorkerImplTest, ReceiveUpdates) {
+TEST_F(CommitQueueImplTest, ReceiveUpdates) {
   NormalInitialize();
 
   const std::string& tag_hash = GenerateTagHash("tag1");
 
   TriggerUpdateFromServer(10, "tag1", "value1");
 
   ASSERT_EQ(1U, GetNumModelThreadUpdateResponses());
   UpdateResponseDataList updates_list = GetNthModelThreadUpdateResponse(0);
   ASSERT_EQ(1U, updates_list.size());
 
   ASSERT_TRUE(HasUpdateResponseOnModelThread("tag1"));
   UpdateResponseData update = GetUpdateResponseOnModelThread("tag1");
 
   EXPECT_FALSE(update.id.empty());
   EXPECT_EQ(tag_hash, update.client_tag_hash);
   EXPECT_LT(0, update.response_version);
   EXPECT_FALSE(update.ctime.is_null());
   EXPECT_FALSE(update.mtime.is_null());
   EXPECT_FALSE(update.non_unique_name.empty());
   EXPECT_FALSE(update.deleted);
   EXPECT_EQ("tag1", update.specifics.preference().name());
   EXPECT_EQ("value1", update.specifics.preference().value());
 }
 
 // Test commit of encrypted updates.
-TEST_F(ModelTypeSyncWorkerImplTest, EncryptedCommit) {
+TEST_F(CommitQueueImplTest, EncryptedCommit) {
   NormalInitialize();
 
   ASSERT_EQ(0U, GetNumModelThreadUpdateResponses());
 
   NewForeignEncryptionKey();
   UpdateLocalCryptographer();
 
   ASSERT_EQ(1U, GetNumModelThreadUpdateResponses());
   EXPECT_EQ(GetLocalCryptographerKeyName(),
             GetNthModelThreadUpdateState(0).encryption_key_name);
@@ skipping 12 matching lines @@
   // The title should be overwritten.
   EXPECT_EQ(tag1_entity.name(), "encrypted");
 
   // The type should be set, but there should be no non-encrypted contents.
   EXPECT_TRUE(tag1_entity.specifics().has_preference());
   EXPECT_FALSE(tag1_entity.specifics().preference().has_name());
   EXPECT_FALSE(tag1_entity.specifics().preference().has_value());
 }
 
 // Test items are not committed when encryption is required but unavailable.
-TEST_F(ModelTypeSyncWorkerImplTest, EncryptionBlocksCommits) {
+TEST_F(CommitQueueImplTest, EncryptionBlocksCommits) {
   NormalInitialize();
 
   CommitRequest("tag1", "value1");
   EXPECT_TRUE(WillCommit());
 
   // We know encryption is in use on this account, but don't have the necessary
   // encryption keys.  The worker should refuse to commit.
   NewForeignEncryptionKey();
   EXPECT_FALSE(WillCommit());
 
@@ skipping 12 matching lines @@
   const sync_pb::SyncEntity& tag1_entity =
       GetLatestCommitEntityOnServer("tag1");
   EXPECT_TRUE(tag1_entity.specifics().has_encrypted());
   EXPECT_EQ(tag1_entity.name(), "encrypted");
   EXPECT_TRUE(tag1_entity.specifics().has_preference());
   EXPECT_FALSE(tag1_entity.specifics().preference().has_name());
   EXPECT_FALSE(tag1_entity.specifics().preference().has_value());
 }
 
 // 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.
   NewForeignEncryptionKey();
   UpdateLocalCryptographer();
 
   // First, receive an unencrypted entry.
   TriggerUpdateFromServer(10, "tag1", "value1");
 
   // Test some basic properties regarding the update.
@@ skipping 10 matching lines @@
   TriggerUpdateFromServer(10, "tag2", "value2");
 
   // Test its basic features and the value of encryption_key_name.
   ASSERT_TRUE(HasUpdateResponseOnModelThread("tag2"));
   UpdateResponseData update2 = GetUpdateResponseOnModelThread("tag2");
   EXPECT_EQ("tag2", update2.specifics.preference().name());
   EXPECT_EQ("value2", update2.specifics.preference().value());
   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();
 
   // Then initialize.
   NormalInitialize();
 
   // The worker should tell the model thread about encryption as soon as
   // possible, so that it will have the chance to re-encrypt local data if
   // necessary.
   ASSERT_EQ(1U, GetNumModelThreadUpdateResponses());
   EXPECT_EQ(GetLocalCryptographerKeyName(),
             GetNthModelThreadUpdateState(0).encryption_key_name);
 }
 
 // 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.
   NewForeignEncryptionKey();
 
   // Receive an encrypted with that new key, which we can't access.
   SetUpdateEncryptionFilter(1);
   TriggerUpdateFromServer(10, "tag1", "value1");
 
   // At this point, the cryptographer does not have access to the key, so the
   // updates will be undecryptable.  They'll be transfered to the model thread
   // for safe-keeping as pending updates.
   ASSERT_EQ(1U, GetNumModelThreadUpdateResponses());
   UpdateResponseDataList updates_list = GetNthModelThreadUpdateResponse(0);
   EXPECT_EQ(0U, updates_list.size());
   UpdateResponseDataList pending_updates = GetNthModelThreadPendingUpdates(0);
   EXPECT_EQ(1U, pending_updates.size());
 
   // The update will be delivered as soon as decryption becomes possible.
   UpdateLocalCryptographer();
   ASSERT_TRUE(HasUpdateResponseOnModelThread("tag1"));
   UpdateResponseData update = GetUpdateResponseOnModelThread("tag1");
   EXPECT_EQ("tag1", update.specifics.preference().name());
   EXPECT_EQ("value1", update.specifics.preference().value());
   EXPECT_FALSE(update.encryption_key_name.empty());
 }
 
 // Ensure that even encrypted updates can cause conflicts.
-TEST_F(ModelTypeSyncWorkerImplTest, EncryptedUpdateOverridesPendingCommit) {
+TEST_F(CommitQueueImplTest, EncryptedUpdateOverridesPendingCommit) {
   NormalInitialize();
 
   // Prepeare to commit an item.
   CommitRequest("tag1", "value1");
   EXPECT_TRUE(WillCommit());
 
   // Receive an encrypted update for that item.
   SetUpdateEncryptionFilter(1);
   TriggerUpdateFromServer(10, "tag1", "value1");
 
   // The pending commit state should be cleared.
   EXPECT_FALSE(WillCommit());
 
   // The encrypted update will be delivered to the model thread.
   ASSERT_EQ(1U, GetNumModelThreadUpdateResponses());
   UpdateResponseDataList updates_list = GetNthModelThreadUpdateResponse(0);
   EXPECT_EQ(0U, updates_list.size());
   UpdateResponseDataList pending_updates = GetNthModelThreadPendingUpdates(0);
   EXPECT_EQ(1U, pending_updates.size());
 }
 
 // Test decryption of pending updates saved across a restart.
-TEST_F(ModelTypeSyncWorkerImplTest, RestorePendingEntries) {
+TEST_F(CommitQueueImplTest, RestorePendingEntries) {
   // Create a fake pending update.
   UpdateResponseData update;
 
   update.client_tag_hash = GenerateTagHash("tag1");
   update.id = "SomeID";
   update.response_version = 100;
   update.ctime = base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(10);
   update.mtime = base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(11);
   update.non_unique_name = "encrypted";
   update.deleted = false;
 
   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);
 
   // Update will be undecryptable at first.
   EXPECT_EQ(0U, GetNumModelThreadUpdateResponses());
   ASSERT_FALSE(HasUpdateResponseOnModelThread("tag1"));
 
   // Update the cryptographer so it can decrypt that update.
   NewForeignEncryptionKey();
   UpdateLocalCryptographer();
 
   // Verify the item gets decrypted and sent back to the model thread.
   ASSERT_TRUE(HasUpdateResponseOnModelThread("tag1"));
 }
 
 // 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();
 
   // Create a fake pending update.
   UpdateResponseData update;
   update.client_tag_hash = GenerateTagHash("tag1");
   update.id = "SomeID";
   update.response_version = 100;
   update.ctime = base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(10);
   update.mtime = base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(11);
   update.non_unique_name = "encrypted";
   update.deleted = false;
 
   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);
 
   // Verify the item gets decrypted and sent back to the model thread.
   ASSERT_TRUE(HasUpdateResponseOnModelThread("tag1"));
 }
 
 // Test that undecryptable updates provide sufficient reason to not commit.
 //
 // 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.
   CommitRequest("tag1", "value1");
   EXPECT_TRUE(WillCommit());
 
   // Receive an encrypted update for that item.
   SetUpdateEncryptionFilter(1);
   TriggerUpdateFromServer(10, "tag1", "value1");
 
   // The pending commit state should be cleared.
   EXPECT_FALSE(WillCommit());
 
   // The pending update will be delivered to the model thread.
   HasUpdateResponseOnModelThread("tag1");
 
   // Pretend the update arrived too late to prevent another commit request.
   CommitRequest("tag1", "value2");
 
   EXPECT_FALSE(WillCommit());
 }
 
 // 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();
   UpdateLocalCryptographer();
 
   // Manually create an update.
   sync_pb::SyncEntity entity;
   entity.set_client_defined_unique_tag(GenerateTagHash("tag1"));
   entity.set_id_string("SomeID");
   entity.set_version(1);
@@ skipping 18 matching lines @@
 
   EXPECT_FALSE(HasUpdateResponseOnModelThread("tag1"));
 
   // Deliver a non-corrupt update to see if the everything still works.
   SetUpdateEncryptionFilter(1);
   TriggerUpdateFromServer(10, "tag1", "value1");
   EXPECT_TRUE(HasUpdateResponseOnModelThread("tag1"));
 }
 
 }  // namespace syncer