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

components/sync/core_impl/test/test_entry_factory.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/internal_api/public/test/test_entry_factory.h"
+#include "components/sync/core/test/test_entry_factory.h"
 
 #include <stdint.h>
 
-#include "sync/syncable/directory.h"
-#include "sync/syncable/entry.h"
-#include "sync/syncable/mutable_entry.h"
-#include "sync/syncable/syncable_id.h"
-#include "sync/syncable/syncable_read_transaction.h"
-#include "sync/syncable/syncable_util.h"
-#include "sync/syncable/syncable_write_transaction.h"
-#include "sync/test/engine/test_id_factory.h"
+#include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/entry.h"
+#include "components/sync/syncable/mutable_entry.h"
+#include "components/sync/syncable/syncable_id.h"
+#include "components/sync/syncable/syncable_read_transaction.h"
+#include "components/sync/syncable/syncable_util.h"
+#include "components/sync/syncable/syncable_write_transaction.h"
+#include "components/sync/test/engine/test_id_factory.h"
 
 using std::string;
 
 namespace syncer {
 
 using syncable::Id;
 using syncable::MutableEntry;
 using syncable::UNITTEST;
 using syncable::WriteTransaction;
 
-TestEntryFactory::TestEntryFactory(syncable::Directory *dir)
-    : directory_(dir), next_revision_(1) {
-}
+TestEntryFactory::TestEntryFactory(syncable::Directory* dir)
+    : directory_(dir), next_revision_(1) {}
 
-TestEntryFactory::~TestEntryFactory() { }
+TestEntryFactory::~TestEntryFactory() {}
 
 int64_t TestEntryFactory::CreateUnappliedNewItemWithParent(
     const string& item_id,
     const sync_pb::EntitySpecifics& specifics,
     const string& parent_id) {
   WriteTransaction trans(FROM_HERE, UNITTEST, directory_);
   MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
-      Id::CreateFromServerId(item_id));
+                     Id::CreateFromServerId(item_id));
   DCHECK(entry.good());
   entry.PutServerVersion(GetNextRevision());
   entry.PutIsUnappliedUpdate(true);
 
   entry.PutServerNonUniqueName(item_id);
   entry.PutServerParentId(Id::CreateFromServerId(parent_id));
   entry.PutServerIsDir(true);
   entry.PutServerSpecifics(specifics);
   return entry.GetMetahandle();
 }
 
 int64_t TestEntryFactory::CreateUnappliedNewBookmarkItemWithParent(
     const string& item_id,
     const sync_pb::EntitySpecifics& specifics,
     const string& parent_id) {
   WriteTransaction trans(FROM_HERE, UNITTEST, directory_);
   MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
-      Id::CreateFromServerId(item_id));
+                     Id::CreateFromServerId(item_id));
   DCHECK(entry.good());
   entry.PutServerVersion(GetNextRevision());
   entry.PutIsUnappliedUpdate(true);
 
   entry.PutServerNonUniqueName(item_id);
   entry.PutServerParentId(Id::CreateFromServerId(parent_id));
   entry.PutServerIsDir(true);
   entry.PutServerSpecifics(specifics);
 
   return entry.GetMetahandle();
 }
 
 int64_t TestEntryFactory::CreateUnappliedNewItem(
     const string& item_id,
     const sync_pb::EntitySpecifics& specifics,
     bool is_unique) {
   WriteTransaction trans(FROM_HERE, UNITTEST, directory_);
   MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
-      Id::CreateFromServerId(item_id));
+                     Id::CreateFromServerId(item_id));
   DCHECK(entry.good());
   entry.PutServerVersion(GetNextRevision());
   entry.PutIsUnappliedUpdate(true);
   entry.PutServerNonUniqueName(item_id);
   entry.PutServerParentId(syncable::Id::GetRoot());
   entry.PutServerIsDir(is_unique);
   entry.PutServerSpecifics(specifics);
   if (is_unique) {  // For top-level nodes.
     entry.PutUniqueServerTag(
-              ModelTypeToRootTag(GetModelTypeFromSpecifics(specifics)));
+        ModelTypeToRootTag(GetModelTypeFromSpecifics(specifics)));
   }
   return entry.GetMetahandle();
 }
 
 void TestEntryFactory::CreateUnsyncedItem(const Id& item_id,
                                           const Id& parent_id,
                                           const string& name,
                                           bool is_folder,
                                           ModelType model_type,
                                           int64_t* metahandle_out) {
   if (is_folder) {
     DCHECK_EQ(model_type, BOOKMARKS);
   }
 
   WriteTransaction trans(FROM_HERE, UNITTEST, directory_);
 
   MutableEntry entry(&trans, syncable::CREATE, model_type, parent_id, name);
   DCHECK(entry.good());
   entry.PutId(item_id);
-  entry.PutBaseVersion(
-      item_id.ServerKnows() ? GetNextRevision() : 0);
+  entry.PutBaseVersion(item_id.ServerKnows() ? GetNextRevision() : 0);
   entry.PutIsUnsynced(true);
   entry.PutIsDir(is_folder);
   entry.PutIsDel(false);
   entry.PutParentId(parent_id);
   sync_pb::EntitySpecifics default_specifics;
   AddDefaultFieldValue(model_type, &default_specifics);
   entry.PutSpecifics(default_specifics);
 
   if (item_id.ServerKnows()) {
     entry.PutServerSpecifics(default_specifics);
     entry.PutServerIsDir(false);
     entry.PutServerParentId(parent_id);
     entry.PutServerIsDel(false);
   }
   if (metahandle_out)
     *metahandle_out = entry.GetMetahandle();
 }
 
 int64_t TestEntryFactory::CreateUnappliedAndUnsyncedBookmarkItem(
     const string& name) {
   int64_t metahandle = 0;
-  CreateUnsyncedItem(
-      TestIdFactory::MakeServer(name), TestIdFactory::root(),
-      name, false, BOOKMARKS, &metahandle);
+  CreateUnsyncedItem(TestIdFactory::MakeServer(name), TestIdFactory::root(),
+                     name, false, BOOKMARKS, &metahandle);
 
   WriteTransaction trans(FROM_HERE, UNITTEST, directory_);
   MutableEntry entry(&trans, syncable::GET_BY_HANDLE, metahandle);
   if (!entry.good()) {
     NOTREACHED();
     return syncable::kInvalidMetaHandle;
   }
 
   entry.PutIsUnappliedUpdate(true);
   entry.PutServerVersion(GetNextRevision());
@@ skipping 159 matching lines @@
     return false;
   }
   return entry.GetIsUnappliedUpdate();
 }
 
 int64_t TestEntryFactory::GetNextRevision() {
   return next_revision_++;
 }
 
 }  // namespace syncer