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

components/sync/engine_impl/get_commit_ids.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/get_commit_ids.h"
+#include "components/sync/engine_impl/get_commit_ids.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
 #include <vector>
 
 #include "base/macros.h"
-#include "sync/engine/syncer_util.h"
-#include "sync/syncable/directory.h"
-#include "sync/syncable/entry.h"
-#include "sync/syncable/nigori_handler.h"
-#include "sync/syncable/nigori_util.h"
-#include "sync/syncable/syncable_base_transaction.h"
-#include "sync/syncable/syncable_util.h"
-#include "sync/util/cryptographer.h"
+#include "components/sync/base/cryptographer.h"
+#include "components/sync/engine_impl/syncer_util.h"
+#include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/entry.h"
+#include "components/sync/syncable/nigori_handler.h"
+#include "components/sync/syncable/nigori_util.h"
+#include "components/sync/syncable/syncable_base_transaction.h"
+#include "components/sync/syncable/syncable_util.h"
 
 using std::set;
 using std::vector;
 
 namespace syncer {
 
 namespace {
 
 // Forward-declare some helper functions.  This gives us more options for
 // ordering the function defintions within this file.
@@ skipping 13 matching lines @@
 // |max_entries| of them in the output parameter |out|.
 //
 // See the header file for an explanation of commit ordering.
 void OrderCommitIds(syncable::BaseTransaction* trans,
                     size_t max_entries,
                     const std::set<int64_t>& ready_unsynced_set,
                     std::vector<int64_t>* out);
 
 }  // namespace
 
-void GetCommitIdsForType(
-    syncable::BaseTransaction* trans,
-    ModelType type,
-    size_t max_entries,
-    syncable::Directory::Metahandles* out) {
+void GetCommitIdsForType(syncable::BaseTransaction* trans,
+                         ModelType type,
+                         size_t max_entries,
+                         syncable::Directory::Metahandles* out) {
   syncable::Directory* dir = trans->directory();
 
   // Gather the full set of unsynced items and store it in the session. They
   // are not in the correct order for commit.
   std::set<int64_t> ready_unsynced_set;
   syncable::Directory::Metahandles all_unsynced_handles;
   GetUnsyncedEntries(trans, &all_unsynced_handles);
 
   ModelTypeSet encrypted_types;
   bool passphrase_missing = false;
   Cryptographer* cryptographer = dir->GetCryptographer(trans);
   if (cryptographer) {
     encrypted_types = dir->GetNigoriHandler()->GetEncryptedTypes(trans);
     passphrase_missing = cryptographer->has_pending_keys();
   }
 
   // We filter out all unready entries from the set of unsynced handles. This
   // new set of ready and unsynced items is then what we use to determine what
   // is a candidate for commit.  The caller is responsible for ensuring that no
   // throttled types are included among the requested_types.
-  FilterUnreadyEntries(trans,
-                       ModelTypeSet(type),
-                       encrypted_types,
-                       passphrase_missing,
-                       all_unsynced_handles,
+  FilterUnreadyEntries(trans, ModelTypeSet(type), encrypted_types,
+                       passphrase_missing, all_unsynced_handles,
                        &ready_unsynced_set);
 
   OrderCommitIds(trans, max_entries, ready_unsynced_set, out);
 
   for (size_t i = 0; i < out->size(); i++) {
     DVLOG(1) << "Debug commit batch result:" << (*out)[i];
   }
 }
 
 namespace {
 
 bool IsEntryInConflict(const syncable::Entry& entry) {
-  if (entry.GetIsUnsynced() &&
-      entry.GetServerVersion() > 0 &&
+  if (entry.GetIsUnsynced() && entry.GetServerVersion() > 0 &&
       (entry.GetServerVersion() > entry.GetBaseVersion())) {
     // The local and server versions don't match. The item must be in
     // conflict, so there's no point in attempting to commit.
     DCHECK(entry.GetIsUnappliedUpdate());
-    DVLOG(1) << "Excluding entry from commit due to version mismatch "
-             << entry;
+    DVLOG(1) << "Excluding entry from commit due to version mismatch " << entry;
     return true;
   }
   return false;
 }
 
 // Return true if this entry has any attachments that haven't yet been uploaded
 // to the server.
 bool HasAttachmentNotOnServer(const syncable::Entry& entry) {
   const sync_pb::AttachmentMetadata& metadata = entry.GetAttachmentMetadata();
   for (int i = 0; i < metadata.record_size(); ++i) {
@@ skipping 374 matching lines @@
 
 void Traversal::AddCreatesAndMoves(
     const std::set<int64_t>& ready_unsynced_set) {
   // Add moves and creates, and prepend their uncommitted parents.
   for (std::set<int64_t>::const_iterator iter = ready_unsynced_set.begin();
        !IsFull() && iter != ready_unsynced_set.end(); ++iter) {
     int64_t metahandle = *iter;
     if (HaveItem(metahandle))
       continue;
 
-    syncable::Entry entry(trans_,
-                          syncable::GET_BY_HANDLE,
-                          metahandle);
+    syncable::Entry entry(trans_, syncable::GET_BY_HANDLE, metahandle);
     if (!entry.GetIsDel()) {
       if (SupportsHierarchy(entry)) {
         // We only commit an item + its dependencies if it and all its
         // dependencies are not in conflict.
         syncable::Directory::Metahandles item_dependencies;
         AddUncommittedParents(ready_unsynced_set, entry, &item_dependencies);
         TryAddItem(ready_unsynced_set, entry, &item_dependencies);
         AppendManyToTraversal(item_dependencies);
       } else {
         // No hierarchy dependencies, just commit the item itself.
@@ skipping 19 matching lines @@
     int64_t metahandle = *iter;
 
     if (HaveItem(metahandle))
       continue;
 
     if (std::find(deletion_list.begin(), deletion_list.end(), metahandle) !=
         deletion_list.end()) {
       continue;
     }
 
-    syncable::Entry entry(trans_, syncable::GET_BY_HANDLE,
-                          metahandle);
+    syncable::Entry entry(trans_, syncable::GET_BY_HANDLE, metahandle);
 
     if (entry.GetIsDel()) {
       if (SupportsHierarchy(entry)) {
         syncable::Directory::Metahandles parents;
         AddDeletedParents(ready_unsynced_set, entry, deletion_list, &parents);
         // Append parents and chilren in top to bottom order.
         deletion_list.insert(deletion_list.end(), parents.begin(),
                              parents.end());
       }
       deletion_list.push_back(metahandle);
@@ skipping 28 matching lines @@
   // Add moves and creates, and prepend their uncommitted parents.
   traversal.AddCreatesAndMoves(ready_unsynced_set);
 
   // Add all deletes.
   traversal.AddDeletes(ready_unsynced_set);
 }
 
 }  // namespace
 
 }  // namespace syncer