[Sync] Move sessions/ to engine/cycle/ and rename things to match.

components/sync/engine_impl/directory_update_handler.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 "components/sync/engine_impl/directory_update_handler.h"
 
 #include <stdint.h>
 
 #include <vector>
 
 #include "components/sync/base/data_type_histogram.h"
 #include "components/sync/engine_impl/conflict_resolver.h"
+#include "components/sync/engine_impl/cycle/directory_type_debug_info_emitter.h"
 #include "components/sync/engine_impl/process_updates_util.h"
 #include "components/sync/engine_impl/update_applicator.h"
-#include "components/sync/sessions_impl/directory_type_debug_info_emitter.h"
 #include "components/sync/syncable/directory.h"
 #include "components/sync/syncable/model_neutral_mutable_entry.h"
 #include "components/sync/syncable/syncable_changes_version.h"
 #include "components/sync/syncable/syncable_model_neutral_write_transaction.h"
 #include "components/sync/syncable/syncable_write_transaction.h"
 
 namespace syncer {
 
 using syncable::SYNCER;
 
@@ skipping 21 matching lines @@
 void DirectoryUpdateHandler::GetDataTypeContext(
     sync_pb::DataTypeContext* context) const {
   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
   dir_->GetDataTypeContext(&trans, type_, context);
 }
 
 SyncerError DirectoryUpdateHandler::ProcessGetUpdatesResponse(
     const sync_pb::DataTypeProgressMarker& progress_marker,
     const sync_pb::DataTypeContext& mutated_context,
     const SyncEntityList& applicable_updates,
-    sessions::StatusController* status) {
+    StatusController* status) {
   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
   if (progress_marker.ByteSize() > 0) {
     SyncRecordDatatypeBin("DataUse.Sync.ProgressMarker.Bytes",
                           ModelTypeToHistogramInt(type_),
                           progress_marker.ByteSize());
   }
   if (mutated_context.has_context()) {
     sync_pb::DataTypeContext local_context;
     dir_->GetDataTypeContext(&trans, type_, &local_context);
 
@@ skipping 42 matching lines @@
     // then the type gets re-enabled again.
     DVLOG(1) << "Type root folder " << ModelTypeToRootTag(type_)
              << " already exists.";
     return;
   }
 
   entry.PutServerIsDir(true);
   entry.PutUniqueServerTag(ModelTypeToRootTag(type_));
 }
 
-void DirectoryUpdateHandler::ApplyUpdates(sessions::StatusController* status) {
+void DirectoryUpdateHandler::ApplyUpdates(StatusController* status) {
   if (IsApplyUpdatesRequired()) {
     // 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(&DirectoryUpdateHandler::ApplyUpdatesImpl,
                    // We wait until the callback is executed.  We can safely use
                    // Unretained.
                    base::Unretained(this), base::Unretained(status));
     worker_->DoWorkAndWaitUntilDone(c);
 
     debug_info_emitter_->EmitUpdateCountersUpdate();
     debug_info_emitter_->EmitStatusCountersUpdate();
   }
 
   PostApplyUpdates();
 }
 
-void DirectoryUpdateHandler::PassiveApplyUpdates(
-    sessions::StatusController* status) {
+void DirectoryUpdateHandler::PassiveApplyUpdates(StatusController* status) {
   if (IsApplyUpdatesRequired()) {
     // Just do the work here instead of deferring to another thread.
     ApplyUpdatesImpl(status);
 
     debug_info_emitter_->EmitUpdateCountersUpdate();
     debug_info_emitter_->EmitStatusCountersUpdate();
   }
 
   PostApplyUpdates();
 }
 
-SyncerError DirectoryUpdateHandler::ApplyUpdatesImpl(
-    sessions::StatusController* status) {
+SyncerError DirectoryUpdateHandler::ApplyUpdatesImpl(StatusController* status) {
   syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER, dir_);
 
   std::vector<int64_t> handles;
   dir_->GetUnappliedUpdateMetaHandles(&trans, FullModelTypeSet(type_),
                                       &handles);
 
   // First set of update application passes.
   UpdateApplicator applicator(dir_->GetCryptographer(&trans));
   applicator.AttemptApplications(&trans, handles);
 
@@ skipping 76 matching lines @@
   if (IsControlType(type_)) {
     return false;  // We don't process control types here.
   }
 
   return dir_->TypeHasUnappliedUpdates(type_);
 }
 
 void DirectoryUpdateHandler::UpdateSyncEntities(
     syncable::ModelNeutralWriteTransaction* trans,
     const SyncEntityList& applicable_updates,
-    sessions::StatusController* status) {
+    StatusController* status) {
   UpdateCounters* counters = debug_info_emitter_->GetMutableUpdateCounters();
   counters->num_updates_received += applicable_updates.size();
   ProcessDownloadedUpdates(dir_, trans, type_, applicable_updates, status,
                            counters);
 }
 
 bool DirectoryUpdateHandler::IsValidProgressMarker(
     const sync_pb::DataTypeProgressMarker& progress_marker) const {
   if (progress_marker.token().empty()) {
     return false;
@@ skipping 44 matching lines @@
            new_gc_directive.version_watermark())) {
     ExpireEntriesByVersion(dir_, trans, type_,
                            new_gc_directive.version_watermark());
   }
 
   cached_gc_directive_.reset(
       new sync_pb::GarbageCollectionDirective(new_gc_directive));
 }
 
 }  // namespace syncer