[Sync] Move //sync to //components/sync.

components/sync/engine_impl/directory_commit_contribution.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_commit_contribution.h"
+#include "components/sync/engine_impl/directory_commit_contribution.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <set>
 
-#include "sync/engine/commit_util.h"
-#include "sync/engine/get_commit_ids.h"
-#include "sync/engine/syncer_util.h"
-#include "sync/internal_api/public/sessions/commit_counters.h"
-#include "sync/syncable/model_neutral_mutable_entry.h"
-#include "sync/syncable/syncable_model_neutral_write_transaction.h"
+#include "components/sync/engine_impl/commit_util.h"
+#include "components/sync/engine_impl/get_commit_ids.h"
+#include "components/sync/engine_impl/syncer_util.h"
+#include "components/sync/sessions/commit_counters.h"
+#include "components/sync/syncable/model_neutral_mutable_entry.h"
+#include "components/sync/syncable/syncable_model_neutral_write_transaction.h"
 
 namespace syncer {
 
 using syncable::GET_BY_HANDLE;
 using syncable::SYNCER;
 
 DirectoryCommitContribution::~DirectoryCommitContribution() {
   DCHECK(!syncing_bits_set_);
 }
 
@@ skipping 28 matching lines @@
   return std::unique_ptr<DirectoryCommitContribution>(
       new DirectoryCommitContribution(metahandles, entities, context, dir,
                                       debug_info_emitter));
 }
 
 void DirectoryCommitContribution::AddToCommitMessage(
     sync_pb::ClientToServerMessage* msg) {
   DCHECK(syncing_bits_set_);
   sync_pb::CommitMessage* commit_message = msg->mutable_commit();
   entries_start_index_ = commit_message->entries_size();
-  std::copy(entities_.begin(),
-            entities_.end(),
+  std::copy(entities_.begin(), entities_.end(),
             RepeatedPtrFieldBackInserter(commit_message->mutable_entries()));
   if (!context_.context().empty())
     commit_message->add_client_contexts()->Swap(&context_);
 
   CommitCounters* counters = debug_info_emitter_->GetMutableCommitCounters();
   counters->num_commits_attempted += entities_.size();
 }
 
 SyncerError DirectoryCommitContribution::ProcessCommitResponse(
     const sync_pb::ClientToServerResponse& response,
     sessions::StatusController* status) {
   DCHECK(syncing_bits_set_);
   const sync_pb::CommitResponse& commit_response = response.commit();
 
   int transient_error_commits = 0;
   int conflicting_commits = 0;
   int error_commits = 0;
   int successes = 0;
 
   std::set<syncable::Id> deleted_folders;
   {
     syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
     for (size_t i = 0; i < metahandles_.size(); ++i) {
       sync_pb::CommitResponse::ResponseType response_type =
           commit_util::ProcessSingleCommitResponse(
-              &trans,
-              commit_response.entryresponse(entries_start_index_ + i),
-              entities_.Get(i),
-              metahandles_[i],
-              &deleted_folders);
+              &trans, commit_response.entryresponse(entries_start_index_ + i),
+              entities_.Get(i), metahandles_[i], &deleted_folders);
       switch (response_type) {
         case sync_pb::CommitResponse::INVALID_MESSAGE:
           ++error_commits;
           break;
         case sync_pb::CommitResponse::CONFLICT:
           ++conflicting_commits;
           status->increment_num_server_conflicts();
           break;
         case sync_pb::CommitResponse::SUCCESS:
           ++successes;
           {
             syncable::Entry e(&trans, GET_BY_HANDLE, metahandles_[i]);
             if (e.GetModelType() == BOOKMARKS)
               status->increment_num_successful_bookmark_commits();
           }
           status->increment_num_successful_commits();
           break;
         case sync_pb::CommitResponse::OVER_QUOTA:
-          // We handle over quota like a retry, which is same as transient.
+        // We handle over quota like a retry, which is same as transient.
         case sync_pb::CommitResponse::RETRY:
         case sync_pb::CommitResponse::TRANSIENT_ERROR:
           ++transient_error_commits;
           break;
         default:
           LOG(FATAL) << "Bad return from ProcessSingleCommitResponse";
       }
     }
     MarkDeletedChildrenSynced(dir_, &trans, &deleted_folders);
   }
@@ skipping 62 matching lines @@
     // complete but the Cleanup method is called anyways. It appears these are
     // unset on the assumption that the sync cycle must have finished properly,
     // although that's actually up to the commit response handling logic.
     entry.PutDirtySync(false);
     entry.PutSyncing(false);
   }
   syncing_bits_set_ = false;
 }
 
 }  // namespace syncer