[Sync] Start implementation of migration for USS.

components/sync/engine_impl/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 "components/sync/engine_impl/test_entry_factory.h"
 
+#include "components/sync/base/model_type.h"
 #include "components/sync/syncable/directory.h"
 #include "components/sync/syncable/entry.h"
+#include "components/sync/syncable/model_neutral_mutable_entry.h"
 #include "components/sync/syncable/mutable_entry.h"
 #include "components/sync/syncable/syncable_id.h"
+#include "components/sync/syncable/syncable_model_neutral_write_transaction.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;
@@ skipping 113 matching lines @@
 
   entry.PutIsUnappliedUpdate(true);
   entry.PutServerVersion(GetNextRevision());
 
   return metahandle;
 }
 
 int64_t TestEntryFactory::CreateSyncedItem(const std::string& name,
                                            ModelType model_type,
                                            bool is_folder) {
+  return CreateSyncedItem(name, model_type, is_folder,
+                          sync_pb::EntitySpecifics());
+}
+
+int64_t TestEntryFactory::CreateSyncedItem(
+    const std::string& name,
+    ModelType model_type,
+    bool is_folder,
+    const sync_pb::EntitySpecifics& specifics) {
   WriteTransaction trans(FROM_HERE, UNITTEST, directory_);
 
-  syncable::Id parent_id(TestIdFactory::root());
+  // Use the type root if it exists or the real root otherwise.
+  syncable::Entry root(&trans, syncable::GET_TYPE_ROOT, model_type);
+  syncable::Id parent_id = root.good() ? root.GetId() : TestIdFactory::root();
   syncable::Id item_id(TestIdFactory::MakeServer(name));
   int64_t version = GetNextRevision();
+  base::Time now = base::Time::Now();
 
   MutableEntry entry(&trans, syncable::CREATE, model_type, parent_id, name);
   if (!entry.good()) {
     NOTREACHED();
     return syncable::kInvalidMetaHandle;
   }
 
   entry.PutId(item_id);
+  entry.PutCtime(now);
+  entry.PutMtime(now);
+  entry.PutUniqueClientTag(syncable::GenerateSyncableHash(model_type, name));
   entry.PutBaseVersion(version);
   entry.PutIsUnsynced(false);
   entry.PutNonUniqueName(name);
   entry.PutIsDir(is_folder);
   entry.PutIsDel(false);
   entry.PutParentId(parent_id);
 
-  entry.PutServerVersion(GetNextRevision());
+  entry.PutServerCtime(now);
+  entry.PutServerMtime(now);
+  entry.PutServerVersion(version);
   entry.PutIsUnappliedUpdate(false);
   entry.PutServerNonUniqueName(name);
   entry.PutServerParentId(parent_id);
   entry.PutServerIsDir(is_folder);
   entry.PutServerIsDel(false);
-  entry.PutServerSpecifics(entry.GetSpecifics());
+
+  // Only rewrite the default specifics inside the entry (which have the model
+  // type marker already) if |specifics| actually contains data.
+  if (specifics.ByteSize() > 0) {
+    entry.PutSpecifics(specifics);
+    entry.PutServerSpecifics(specifics);
+  } else {
+    entry.PutServerSpecifics(entry.GetSpecifics());
+  }
 
   return entry.GetMetahandle();
 }
 
+int64_t TestEntryFactory::CreateTypeRootNode(ModelType model_type) {
+  syncable::ModelNeutralWriteTransaction trans(FROM_HERE, syncable::UNITTEST,
+                                               directory_);
+  sync_pb::EntitySpecifics specifics;
+  AddDefaultFieldValue(model_type, &specifics);
+  syncable::ModelNeutralMutableEntry entry(
+      &trans, syncable::CREATE_NEW_TYPE_ROOT, model_type);
+  DCHECK(entry.good());
+  entry.PutServerIsDir(true);
+  entry.PutUniqueServerTag(ModelTypeToRootTag(model_type));
+  return entry.GetMetahandle();
+}
+
 int64_t TestEntryFactory::CreateUnappliedRootNode(ModelType model_type) {
   syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST, directory_);
   sync_pb::EntitySpecifics specifics;
   AddDefaultFieldValue(model_type, &specifics);
   syncable::Id node_id = TestIdFactory::MakeServer("xyz");
   syncable::MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
                                node_id);
   DCHECK(entry.good());
   // Make it look like sort of like a pending creation from the server.
   // The SERVER_PARENT_ID and UNIQUE_CLIENT_TAG aren't quite right, but
@@ skipping 111 matching lines @@
     return false;
   }
   return entry.GetIsUnappliedUpdate();
 }
 
 int64_t TestEntryFactory::GetNextRevision() {
   return next_revision_++;
 }
 
 }  // namespace syncer