sync: Add interfaces for per-type sync

sync/engine/directory_update_handler.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 "sync/engine/conflict_resolver.h"
 #include "sync/engine/process_updates_util.h"
 #include "sync/engine/update_applicator.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/syncable_model_neutral_write_transaction.h"
 #include "sync/syncable/syncable_write_transaction.h"
 
 namespace syncer {
 
 using syncable::SYNCER;
 
-SyncDirectoryUpdateHandler::SyncDirectoryUpdateHandler(
+DirectoryUpdateHandler::DirectoryUpdateHandler(
     syncable::Directory* dir,
     ModelType type,
     scoped_refptr<ModelSafeWorker> worker)
   : dir_(dir),
     type_(type),
     worker_(worker) {}
 
-SyncDirectoryUpdateHandler::~SyncDirectoryUpdateHandler() {}
+DirectoryUpdateHandler::~DirectoryUpdateHandler() {}
 
-void SyncDirectoryUpdateHandler::GetDownloadProgress(
+void DirectoryUpdateHandler::GetDownloadProgress(
     sync_pb::DataTypeProgressMarker* progress_marker) const {
   dir_->GetDownloadProgress(type_, progress_marker);
 }
 
-void SyncDirectoryUpdateHandler::ProcessGetUpdatesResponse(
+void DirectoryUpdateHandler::ProcessGetUpdatesResponse(
     const sync_pb::DataTypeProgressMarker& progress_marker,
     const SyncEntityList& applicable_updates,
     sessions::StatusController* status) {
   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
   UpdateSyncEntities(&trans, applicable_updates, status);
   UpdateProgressMarker(progress_marker);
 }
 
-void SyncDirectoryUpdateHandler::ApplyUpdates(
-    sessions::StatusController* status) {
+void DirectoryUpdateHandler::ApplyUpdates(sessions::StatusController* status) {
   if (!IsApplyUpdatesRequired()) {
     return;
   }
 
   // This will invoke handlers that belong to the model and its thread, so we
   // switch to the appropriate thread before we start this work.
   WorkCallback c = base::Bind(
-      &SyncDirectoryUpdateHandler::ApplyUpdatesImpl,
+      &DirectoryUpdateHandler::ApplyUpdatesImpl,
       // We wait until the callback is executed.  We can safely use Unretained.
       base::Unretained(this),
       base::Unretained(status));
   worker_->DoWorkAndWaitUntilDone(c);
 }
 
-void SyncDirectoryUpdateHandler::PassiveApplyUpdates(
+void DirectoryUpdateHandler::PassiveApplyUpdates(
     sessions::StatusController* status) {
   if (!IsApplyUpdatesRequired()) {
     return;
   }
 
   // Just do the work here instead of deferring to another thread.
   ApplyUpdatesImpl(status);
 }
 
-SyncerError SyncDirectoryUpdateHandler::ApplyUpdatesImpl(
+SyncerError DirectoryUpdateHandler::ApplyUpdatesImpl(
     sessions::StatusController* status) {
   syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER, dir_);
 
   std::vector<int64> handles;
   dir_->GetUnappliedUpdateMetaHandles(
       &trans,
       FullModelTypeSet(type_),
       &handles);
 
   // First set of update application passes.
@@ skipping 46 matching lines @@
     // There should be no simple conflicts remaining.  We know this because the
     // resolver should have resolved all the conflicts we detected last time
     // and, by the two previous assertions, that no conflicts have been
     // downgraded from encryption or hierarchy down to simple.
     DCHECK(conflict_applicator.simple_conflict_ids().empty());
   }
 
   return SYNCER_OK;
 }
 
-bool SyncDirectoryUpdateHandler::IsApplyUpdatesRequired() {
+bool DirectoryUpdateHandler::IsApplyUpdatesRequired() {
   if (IsControlType(type_)) {
     return false;  // We don't process control types here.
   }
 
   return dir_->TypeHasUnappliedUpdates(type_);
 }
 
-void SyncDirectoryUpdateHandler::UpdateSyncEntities(
+void DirectoryUpdateHandler::UpdateSyncEntities(
     syncable::ModelNeutralWriteTransaction* trans,
     const SyncEntityList& applicable_updates,
     sessions::StatusController* status) {
   ProcessDownloadedUpdates(dir_, trans, type_, applicable_updates, status);
 }
 
-void SyncDirectoryUpdateHandler::UpdateProgressMarker(
+void DirectoryUpdateHandler::UpdateProgressMarker(
     const sync_pb::DataTypeProgressMarker& progress_marker) {
   int field_number = progress_marker.data_type_id();
   ModelType model_type = GetModelTypeFromSpecificsFieldNumber(field_number);
   if (!IsRealDataType(model_type) || type_ != model_type) {
     NOTREACHED()
         << "Update handler of type " << ModelTypeToString(type_)
         << " asked to process progress marker with invalid type "
         << field_number;
   }
   dir_->SetDownloadProgress(type_, progress_marker);
 }
 
 }  // namespace syncer