[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) {
+  int64_t version = GetNextRevision();
+  base::Time now = base::Time::Now();

[skym, 2016/10/21 15:34:20]

Time::Now() is difficult to test.

[maxbogue, 2016/10/24 19:02:18]

Testing that it's not null seems fine. You'd rather I set up some time constants
in this class?

[skym, 2016/10/25 15:48:12]

Yes, I think I have another comment about wanting them tested.

[maxbogue, 2016/10/26 23:26:15]

Acknowledged.

+  syncable::Id item_id(TestIdFactory::MakeServer(name));
+  syncable::Id parent_id;
+  {
+    syncable::ReadTransaction trans(FROM_HERE, directory_);

[skym, 2016/10/21 15:34:20]

Why not move the WriteTransaction up higher and re-use it here?

[maxbogue, 2016/10/24 19:02:18]

Didn't occur to me that you could use a WriteTransaction to read... done.

+    syncable::Entry root(&trans, syncable::GET_TYPE_ROOT, model_type);
+    if (root.good()) {
+      parent_id = root.GetId();
+    } else {
+      parent_id = TestIdFactory::root();
+    }
+  }
+
   WriteTransaction trans(FROM_HERE, UNITTEST, directory_);
-
-  syncable::Id parent_id(TestIdFactory::root());
-  syncable::Id item_id(TestIdFactory::MakeServer(name));
-  int64_t version = GetNextRevision();
-
   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 (which have the model type marker
+  // already) if the new ones have data in them.
+  if (specifics.ByteSize() > 0) {

[skym, 2016/10/21 15:34:20]

How can specifics have the model type marker and yet can be 0 bytes?

[maxbogue, 2016/10/24 19:02:18]

The default specifics already in the entry have the model type marker. This is
checking if the new ones passed in are set or not to maintain backward
compatibility with other tests.

[skym, 2016/10/25 15:48:11]

Gotcha. Can you update this comment to mention where the default specifics live.
I thought you were referring to the case where |specifics| was not initialized,
and thus had default values.

[maxbogue, 2016/10/26 23:26:15]

Done.

+    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