[Sync] //components/sync internal changes [DO NOT SUBMIT]

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 "sync/engine/directory_update_handler.h"
+#include "components/sync/engine_impl/directory_update_handler.h"
 
 #include <stdint.h>
 
 #include <vector>
 
-#include "sync/engine/conflict_resolver.h"
-#include "sync/engine/process_updates_util.h"
-#include "sync/engine/update_applicator.h"
-#include "sync/sessions/directory_type_debug_info_emitter.h"
-#include "sync/syncable/directory.h"
-#include "sync/syncable/model_neutral_mutable_entry.h"
-#include "sync/syncable/syncable_changes_version.h"
-#include "sync/syncable/syncable_model_neutral_write_transaction.h"
-#include "sync/syncable/syncable_write_transaction.h"
-#include "sync/util/data_type_histogram.h"
+#include "components/sync/base/data_type_histogram.h"
+#include "components/sync/engine_impl/conflict_resolver.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;
 
 DirectoryUpdateHandler::DirectoryUpdateHandler(
     syncable::Directory* dir,
     ModelType type,
     scoped_refptr<ModelSafeWorker> worker,
     DirectoryTypeDebugInfoEmitter* debug_info_emitter)
-  : dir_(dir),
-    type_(type),
-    worker_(worker),
-    debug_info_emitter_(debug_info_emitter) {}
+    : dir_(dir),
+      type_(type),
+      worker_(worker),
+      debug_info_emitter_(debug_info_emitter) {}
 
 DirectoryUpdateHandler::~DirectoryUpdateHandler() {}
 
 bool DirectoryUpdateHandler::IsInitialSyncEnded() const {
   return dir_->InitialSyncEndedForType(type_);
 }
 
 void DirectoryUpdateHandler::GetDownloadProgress(
     sync_pb::DataTypeProgressMarker* progress_marker) const {
   dir_->GetDownloadProgress(type_, progress_marker);
@@ skipping 101 matching lines @@
   }
 
   PostApplyUpdates();
 }
 
 SyncerError DirectoryUpdateHandler::ApplyUpdatesImpl(
     sessions::StatusController* status) {
   syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER, dir_);
 
   std::vector<int64_t> handles;
-  dir_->GetUnappliedUpdateMetaHandles(
-      &trans,
-      FullModelTypeSet(type_),
-      &handles);
+  dir_->GetUnappliedUpdateMetaHandles(&trans, FullModelTypeSet(type_),
+                                      &handles);
 
   // First set of update application passes.
   UpdateApplicator applicator(dir_->GetCryptographer(&trans));
   applicator.AttemptApplications(&trans, handles);
 
   // The old StatusController counters.
   status->increment_num_updates_applied_by(applicator.updates_applied());
   status->increment_num_hierarchy_conflicts_by(
       applicator.hierarchy_conflicts());
   status->increment_num_encryption_conflicts_by(
       applicator.encryption_conflicts());
 
   // The new UpdateCounter counters.
   UpdateCounters* counters = debug_info_emitter_->GetMutableUpdateCounters();
   counters->num_updates_applied += applicator.updates_applied();
   counters->num_hierarchy_conflict_application_failures =
       applicator.hierarchy_conflicts();
   counters->num_encryption_conflict_application_failures +=
       applicator.encryption_conflicts();
 
   if (applicator.simple_conflict_ids().size() != 0) {
     // Resolve the simple conflicts we just detected.
     ConflictResolver resolver;
-    resolver.ResolveConflicts(&trans,
-                              dir_->GetCryptographer(&trans),
-                              applicator.simple_conflict_ids(),
-                              status,
+    resolver.ResolveConflicts(&trans, dir_->GetCryptographer(&trans),
+                              applicator.simple_conflict_ids(), status,
                               counters);
 
     // Conflict resolution sometimes results in more updates to apply.
     handles.clear();
-    dir_->GetUnappliedUpdateMetaHandles(
-        &trans,
-        FullModelTypeSet(type_),
-        &handles);
+    dir_->GetUnappliedUpdateMetaHandles(&trans, FullModelTypeSet(type_),
+                                        &handles);
 
     UpdateApplicator conflict_applicator(dir_->GetCryptographer(&trans));
     conflict_applicator.AttemptApplications(&trans, handles);
 
     // We count the number of updates from both applicator passes.
     status->increment_num_updates_applied_by(
         conflict_applicator.updates_applied());
     counters->num_updates_applied += conflict_applicator.updates_applied();
 
     // Encryption conflicts should remain unchanged by the resolution of simple
@@ skipping 43 matching lines @@
 
   return dir_->TypeHasUnappliedUpdates(type_);
 }
 
 void DirectoryUpdateHandler::UpdateSyncEntities(
     syncable::ModelNeutralWriteTransaction* trans,
     const SyncEntityList& applicable_updates,
     sessions::StatusController* status) {
   UpdateCounters* counters = debug_info_emitter_->GetMutableUpdateCounters();
   counters->num_updates_received += applicable_updates.size();
-  ProcessDownloadedUpdates(dir_, trans, type_,
-                           applicable_updates, status, counters);
+  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;
   }
   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;
+    NOTREACHED() << "Update handler of type " << ModelTypeToString(type_)
+                 << " asked to process progress marker with invalid type "
+                 << field_number;
     return false;
   }
   return true;
 }
 
 void DirectoryUpdateHandler::UpdateProgressMarker(
     const sync_pb::DataTypeProgressMarker& progress_marker) {
   if (progress_marker.has_gc_directive() || !cached_gc_directive_) {
     dir_->SetDownloadProgress(type_, progress_marker);
   } else {
@@ skipping 16 matching lines @@
   }
 
   if (!progress_marker.has_gc_directive())
     return;
 
   const sync_pb::GarbageCollectionDirective& new_gc_directive =
       progress_marker.gc_directive();
 
   if (new_gc_directive.has_version_watermark() &&
       (!cached_gc_directive_ ||
-          cached_gc_directive_->version_watermark() <
-              new_gc_directive.version_watermark())) {
+       cached_gc_directive_->version_watermark() <
+           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