[Sync] rename USS processor / worker interfaces

sync/engine/commit_queue_impl.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/bind.h"
 #include "base/format_macros.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "sync/engine/commit_contribution.h"
 #include "sync/engine/entity_tracker.h"
-#include "sync/engine/model_type_sync_proxy.h"
+#include "sync/engine/model_type_processor.h"
 #include "sync/engine/non_blocking_type_commit_contribution.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/util/cryptographer.h"
 #include "sync/util/time.h"
 
 namespace syncer_v2 {
 
 using syncer::CommitContribution;
 using syncer::Cryptographer;
 using syncer::ModelType;
 using syncer::NudgeHandler;
 using syncer::SyncerError;
 
-ModelTypeSyncWorkerImpl::ModelTypeSyncWorkerImpl(
+CommitQueueImpl::CommitQueueImpl(
     ModelType type,
     const DataTypeState& initial_state,
     const UpdateResponseDataList& saved_pending_updates,
     scoped_ptr<Cryptographer> cryptographer,
     NudgeHandler* nudge_handler,
-    scoped_ptr<ModelTypeSyncProxy> type_sync_proxy)
+    scoped_ptr<ModelTypeProcessor> type_sync_proxy)
     : type_(type),
       data_type_state_(initial_state),
       type_sync_proxy_(type_sync_proxy.Pass()),
       cryptographer_(cryptographer.Pass()),
       nudge_handler_(nudge_handler),
       weak_ptr_factory_(this) {
   // Request an initial sync if it hasn't been completed yet.
   if (!data_type_state_.initial_sync_done) {
     nudge_handler_->NudgeForInitialDownload(type_);
   }
 
   for (UpdateResponseDataList::const_iterator it =
            saved_pending_updates.begin();
        it != saved_pending_updates.end(); ++it) {
     scoped_ptr<EntityTracker> entity_tracker = EntityTracker::FromServerUpdate(
         it->id, it->client_tag_hash, it->response_version);
     entity_tracker->ReceivePendingUpdate(*it);
     entities_.insert(it->client_tag_hash, entity_tracker.Pass());
   }
 
   if (cryptographer_) {
     DVLOG(1) << ModelTypeToString(type_) << ": Starting with encryption key "
              << cryptographer_->GetDefaultNigoriKeyName();
     OnCryptographerUpdated();
   }
 }
 
-ModelTypeSyncWorkerImpl::~ModelTypeSyncWorkerImpl() {
+CommitQueueImpl::~CommitQueueImpl() {
 }
 
-ModelType ModelTypeSyncWorkerImpl::GetModelType() const {
+ModelType CommitQueueImpl::GetModelType() const {
   DCHECK(CalledOnValidThread());
   return type_;
 }
 
-bool ModelTypeSyncWorkerImpl::IsEncryptionRequired() const {
+bool CommitQueueImpl::IsEncryptionRequired() const {
   return !!cryptographer_;
 }
 
-void ModelTypeSyncWorkerImpl::UpdateCryptographer(
+void CommitQueueImpl::UpdateCryptographer(
     scoped_ptr<Cryptographer> cryptographer) {
   DCHECK(cryptographer);
   cryptographer_ = cryptographer.Pass();
 
   // Update our state and that of the proxy.
   OnCryptographerUpdated();
 
   // Nudge the scheduler if we're now allowed to commit.
   if (CanCommitItems())
     nudge_handler_->NudgeForCommit(type_);
 }
 
 // UpdateHandler implementation.
-void ModelTypeSyncWorkerImpl::GetDownloadProgress(
+void CommitQueueImpl::GetDownloadProgress(
     sync_pb::DataTypeProgressMarker* progress_marker) const {
   DCHECK(CalledOnValidThread());
   progress_marker->CopyFrom(data_type_state_.progress_marker);
 }
 
-void ModelTypeSyncWorkerImpl::GetDataTypeContext(
+void CommitQueueImpl::GetDataTypeContext(
     sync_pb::DataTypeContext* context) const {
   DCHECK(CalledOnValidThread());
   context->CopyFrom(data_type_state_.type_context);
 }
 
-SyncerError ModelTypeSyncWorkerImpl::ProcessGetUpdatesResponse(
+SyncerError CommitQueueImpl::ProcessGetUpdatesResponse(
     const sync_pb::DataTypeProgressMarker& progress_marker,
     const sync_pb::DataTypeContext& mutated_context,
     const SyncEntityList& applicable_updates,
     syncer::sessions::StatusController* status) {
   DCHECK(CalledOnValidThread());
 
   // TODO(rlarocque): Handle data type context conflicts.
   data_type_state_.type_context = mutated_context;
   data_type_state_.progress_marker = progress_marker;
 
@@ skipping 76 matching lines @@
                   response_datas.size(),
                   pending_updates.size());
 
   // Forward these updates to the model thread so it can do the rest.
   type_sync_proxy_->OnUpdateReceived(
       data_type_state_, response_datas, pending_updates);
 
   return syncer::SYNCER_OK;
 }
 
-void ModelTypeSyncWorkerImpl::ApplyUpdates(
+void CommitQueueImpl::ApplyUpdates(
     syncer::sessions::StatusController* status) {
   DCHECK(CalledOnValidThread());
   // This function is called only when we've finished a download cycle, ie. we
   // got a response with changes_remaining == 0.  If this is our first download
-  // cycle, we should update our state so the ModelTypeSyncProxy knows that
+  // cycle, we should update our state so the ModelTypeProcessor knows that
   // it's safe to commit items now.
   if (!data_type_state_.initial_sync_done) {
     DVLOG(1) << "Delivering 'initial sync done' ping.";
 
     data_type_state_.initial_sync_done = true;
 
     type_sync_proxy_->OnUpdateReceived(
         data_type_state_, UpdateResponseDataList(), UpdateResponseDataList());
   }
 }
 
-void ModelTypeSyncWorkerImpl::PassiveApplyUpdates(
+void CommitQueueImpl::PassiveApplyUpdates(
     syncer::sessions::StatusController* status) {
   NOTREACHED()
       << "Non-blocking types should never apply updates on sync thread.  "
       << "ModelType is: " << ModelTypeToString(type_);
 }
 
-void ModelTypeSyncWorkerImpl::EnqueueForCommit(
+void CommitQueueImpl::EnqueueForCommit(
     const CommitRequestDataList& list) {
   DCHECK(CalledOnValidThread());
 
   DCHECK(IsTypeInitialized())
       << "Asked to commit items before type was initialized.  "
       << "ModelType is: " << ModelTypeToString(type_);
 
   for (CommitRequestDataList::const_iterator it = list.begin();
        it != list.end(); ++it) {
     StorePendingCommit(*it);
   }
 
   if (CanCommitItems())
     nudge_handler_->NudgeForCommit(type_);
 }
 
 // CommitContributor implementation.
-scoped_ptr<CommitContribution> ModelTypeSyncWorkerImpl::GetContribution(
+scoped_ptr<CommitContribution> CommitQueueImpl::GetContribution(
     size_t max_entries) {
   DCHECK(CalledOnValidThread());
 
   size_t space_remaining = max_entries;
   std::vector<int64> sequence_numbers;
   google::protobuf::RepeatedPtrField<sync_pb::SyncEntity> commit_entities;
 
   if (!CanCommitItems())
     return scoped_ptr<CommitContribution>();
 
@@ skipping 14 matching lines @@
     }
   }
 
   if (commit_entities.size() == 0)
     return scoped_ptr<CommitContribution>();
 
   return scoped_ptr<CommitContribution>(new NonBlockingTypeCommitContribution(
       data_type_state_.type_context, commit_entities, sequence_numbers, this));
 }
 
-void ModelTypeSyncWorkerImpl::StorePendingCommit(
+void CommitQueueImpl::StorePendingCommit(
     const CommitRequestData& request) {
   if (!request.deleted) {
     DCHECK_EQ(type_, syncer::GetModelTypeFromSpecifics(request.specifics));
   }
 
   EntityMap::const_iterator map_it = entities_.find(request.client_tag_hash);
   if (map_it == entities_.end()) {
     scoped_ptr<EntityTracker> entity = EntityTracker::FromCommitRequest(
         request.id, request.client_tag_hash, request.sequence_number,
         request.base_version, request.ctime, request.mtime,
         request.non_unique_name, request.deleted, request.specifics);
     entities_.insert(request.client_tag_hash, entity.Pass());
   } else {
     EntityTracker* entity = map_it->second;
     entity->RequestCommit(request.id,
                           request.client_tag_hash,
                           request.sequence_number,
                           request.base_version,
                           request.ctime,
                           request.mtime,
                           request.non_unique_name,
                           request.deleted,
                           request.specifics);
   }
 }
 
-void ModelTypeSyncWorkerImpl::OnCommitResponse(
+void CommitQueueImpl::OnCommitResponse(
     const CommitResponseDataList& response_list) {
   for (CommitResponseDataList::const_iterator response_it =
            response_list.begin();
        response_it != response_list.end(); ++response_it) {
     const std::string client_tag_hash = response_it->client_tag_hash;
     EntityMap::const_iterator map_it = entities_.find(client_tag_hash);
 
     // There's no way we could have committed an entry we know nothing about.
     if (map_it == entities_.end()) {
       NOTREACHED() << "Received commit response for item unknown to us."
                    << " Model type: " << ModelTypeToString(type_)
                    << " ID: " << response_it->id;
       continue;
     }
 
     EntityTracker* entity = map_it->second;
     entity->ReceiveCommitResponse(response_it->id,
                                   response_it->response_version,
                                   response_it->sequence_number);
   }
 
   // Send the responses back to the model thread.  It needs to know which
   // items have been successfully committed so it can save that information in
   // permanent storage.
   type_sync_proxy_->OnCommitCompleted(data_type_state_, response_list);
 }
 
-base::WeakPtr<ModelTypeSyncWorkerImpl> ModelTypeSyncWorkerImpl::AsWeakPtr() {
+base::WeakPtr<CommitQueueImpl> CommitQueueImpl::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-bool ModelTypeSyncWorkerImpl::IsTypeInitialized() const {
+bool CommitQueueImpl::IsTypeInitialized() const {
   return data_type_state_.initial_sync_done &&
          !data_type_state_.progress_marker.token().empty();
 }
 
-bool ModelTypeSyncWorkerImpl::CanCommitItems() const {
+bool CommitQueueImpl::CanCommitItems() const {
   // We can't commit anything until we know the type's parent node.
   // We'll get it in the first update response.
   if (!IsTypeInitialized())
     return false;
 
   // Don't commit if we should be encrypting but don't have the required keys.
   if (IsEncryptionRequired() &&
       (!cryptographer_ || !cryptographer_->is_ready())) {
     return false;
   }
 
   return true;
 }
 
-void ModelTypeSyncWorkerImpl::HelpInitializeCommitEntity(
+void CommitQueueImpl::HelpInitializeCommitEntity(
     sync_pb::SyncEntity* sync_entity) {
   DCHECK(CanCommitItems());
 
   // Initial commits need our help to generate a client ID.
   if (!sync_entity->has_id_string()) {
     DCHECK_EQ(kUncommittedVersion, sync_entity->version());
     // TODO(stanisc): This is incorrect for bookmarks for two reasons:
     // 1) Won't be able to match previously committed bookmarks to the ones
     //    with server ID.
     // 2) Recommitting an item in a case of failing to receive commit response
@@ skipping 16 matching lines @@
   }
 
   // Always include enough specifics to identify the type.  Do this even in
   // deletion requests, where the specifics are otherwise invalid.
   AddDefaultFieldValue(type_, sync_entity->mutable_specifics());
 
   // TODO(stanisc): crbug.com/516866:
   // Call sync_entity->set_parent_id_string(...) for hierarchical entities here.
 }
 
-void ModelTypeSyncWorkerImpl::OnCryptographerUpdated() {
+void CommitQueueImpl::OnCryptographerUpdated() {
   DCHECK(cryptographer_);
 
   bool new_encryption_key = false;
   UpdateResponseDataList response_datas;
 
   const std::string& new_key_name = cryptographer_->GetDefaultNigoriKeyName();
 
   // Handle a change in encryption key.
   if (data_type_state_.encryption_key_name != new_key_name) {
     DVLOG(1) << ModelTypeToString(type_) << ": Updating encryption key "
@@ skipping 29 matching lines @@
   if (new_encryption_key || response_datas.size() > 0) {
     DVLOG(1) << ModelTypeToString(type_) << ": "
              << base::StringPrintf(
                     "Delivering encryption key and %zd decrypted updates.",
                     response_datas.size());
     type_sync_proxy_->OnUpdateReceived(data_type_state_, response_datas,
                                        UpdateResponseDataList());
   }
 }
 
-bool ModelTypeSyncWorkerImpl::DecryptSpecifics(
+bool CommitQueueImpl::DecryptSpecifics(
     Cryptographer* cryptographer,
     const sync_pb::EntitySpecifics& in,
     sync_pb::EntitySpecifics* out) {
   DCHECK(in.has_encrypted());
   DCHECK(cryptographer->CanDecrypt(in.encrypted()));
 
   std::string plaintext;
   plaintext = cryptographer->DecryptToString(in.encrypted());
   if (plaintext.empty()) {
     LOG(ERROR) << "Failed to decrypt a decryptable entity";
     return false;
   }
   if (!out->ParseFromString(plaintext)) {
     LOG(ERROR) << "Failed to parse decrypted entity";
     return false;
   }
   return true;
 }
 
 }  // namespace syncer