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

components/sync/syncable/mutable_entry.cc

 // Copyright 2012 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/syncable/mutable_entry.h"
+#include "components/sync/syncable/mutable_entry.h"
 
 #include <stdint.h>
 
 #include <memory>
 
-#include "sync/internal_api/public/base/unique_position.h"
-#include "sync/syncable/directory.h"
-#include "sync/syncable/scoped_kernel_lock.h"
-#include "sync/syncable/scoped_parent_child_index_updater.h"
-#include "sync/syncable/syncable-inl.h"
-#include "sync/syncable/syncable_changes_version.h"
-#include "sync/syncable/syncable_util.h"
-#include "sync/syncable/syncable_write_transaction.h"
+#include "components/sync/base/unique_position.h"
+#include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/scoped_kernel_lock.h"
+#include "components/sync/syncable/scoped_parent_child_index_updater.h"
+#include "components/sync/syncable/syncable-inl.h"
+#include "components/sync/syncable/syncable_changes_version.h"
+#include "components/sync/syncable/syncable_util.h"
+#include "components/sync/syncable/syncable_write_transaction.h"
 
 using std::string;
 
 namespace syncer {
 namespace syncable {
 
 void MutableEntry::Init(WriteTransaction* trans,
                         ModelType model_type,
                         const Id& parent_id,
                         const string& name) {
@@ skipping 60 matching lines @@
     kernel_->put(UNIQUE_BOOKMARK_TAG, unique_tag);
     kernel_->put(UNIQUE_POSITION, UniquePosition::InitialPosition(unique_tag));
   } else {
     DCHECK(!ShouldMaintainPosition());
   }
 
   bool result = trans->directory()->InsertEntry(trans, kernel_);
   DCHECK(result);
 }
 
-MutableEntry::MutableEntry(WriteTransaction* trans, CreateNewUpdateItem,
+MutableEntry::MutableEntry(WriteTransaction* trans,
+                           CreateNewUpdateItem,
                            const Id& id)
     : ModelNeutralMutableEntry(trans, CREATE_NEW_UPDATE_ITEM, id),
       write_transaction_(trans) {}
 
 MutableEntry::MutableEntry(WriteTransaction* trans, GetById, const Id& id)
     : ModelNeutralMutableEntry(trans, GET_BY_ID, id),
-      write_transaction_(trans) {
-}
+      write_transaction_(trans) {}
 
 MutableEntry::MutableEntry(WriteTransaction* trans,
                            GetByHandle,
                            int64_t metahandle)
     : ModelNeutralMutableEntry(trans, GET_BY_HANDLE, metahandle),
       write_transaction_(trans) {}
 
-MutableEntry::MutableEntry(WriteTransaction* trans, GetByClientTag,
+MutableEntry::MutableEntry(WriteTransaction* trans,
+                           GetByClientTag,
                            const std::string& tag)
     : ModelNeutralMutableEntry(trans, GET_BY_CLIENT_TAG, tag),
-      write_transaction_(trans) {
-}
+      write_transaction_(trans) {}
 
 MutableEntry::MutableEntry(WriteTransaction* trans, GetTypeRoot, ModelType type)
     : ModelNeutralMutableEntry(trans, GET_TYPE_ROOT, type),
-      write_transaction_(trans) {
-}
+      write_transaction_(trans) {}
 
 void MutableEntry::PutLocalExternalId(int64_t value) {
   DCHECK(kernel_);
   if (kernel_->ref(LOCAL_EXTERNAL_ID) != value) {
     write_transaction()->TrackChangesTo(kernel_);
     ScopedKernelLock lock(dir());
     kernel_->put(LOCAL_EXTERNAL_ID, value);
     MarkDirty();
   }
 }
@@ skipping 60 matching lines @@
     if (!GetId().ServerKnows() && !GetSyncing()) {
       PutIsUnsynced(false);
     }
   }
 
   {
     ScopedKernelLock lock(dir());
     // Some indices don't include deleted items and must be updated
     // upon a value change.
     ScopedParentChildIndexUpdater updater(lock, kernel_,
-        &dir()->kernel()->parent_child_index);
+                                          &dir()->kernel()->parent_child_index);
 
     kernel_->put(IS_DEL, value);
     MarkDirty();
   }
 }
 
 void MutableEntry::PutNonUniqueName(const std::string& value) {
   DCHECK(kernel_);
   if (kernel_->ref(NON_UNIQUE_NAME) != value) {
     write_transaction()->TrackChangesTo(kernel_);
@@ skipping 22 matching lines @@
   }
 }
 
 void MutableEntry::PutUniquePosition(const UniquePosition& value) {
   DCHECK(kernel_);
   if (!kernel_->ref(UNIQUE_POSITION).Equals(value)) {
     write_transaction()->TrackChangesTo(kernel_);
     // We should never overwrite a valid position with an invalid one.
     DCHECK(value.IsValid());
     ScopedKernelLock lock(dir());
-    ScopedParentChildIndexUpdater updater(
-        lock, kernel_, &dir()->kernel()->parent_child_index);
+    ScopedParentChildIndexUpdater updater(lock, kernel_,
+                                          &dir()->kernel()->parent_child_index);
     kernel_->put(UNIQUE_POSITION, value);
     MarkDirty();
   }
 }
 
 bool MutableEntry::PutPredecessor(const Id& predecessor_id) {
   if (predecessor_id.IsNull()) {
     dir()->PutPredecessor(kernel_, NULL);
   } else {
     MutableEntry predecessor(write_transaction(), GET_BY_ID, predecessor_id);
@@ skipping 53 matching lines @@
   DCHECK(!e->IsRoot()) << "We shouldn't mark a permanent object for syncing.";
   if (!(e->PutIsUnsynced(true)))
     return false;
   if (e->GetSyncing())
     e->PutDirtySync(true);
   return true;
 }
 
 }  // namespace syncable
 }  // namespace syncer