[Sync] USS: Filter out tombstones for initial sync.

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/hash_util.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/syncable/directory.h"
 #include "components/sync/syncable/entry.h"
@@ skipping 140 matching lines @@
 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_);
 
   // 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(GenerateSyncableHash(model_type, name));
-  entry.PutBaseVersion(version);
-  entry.PutIsUnsynced(false);
-  entry.PutNonUniqueName(name);
+  PopulateEntry(parent_id, name, model_type, &entry);
   entry.PutIsDir(is_folder);
-  entry.PutIsDel(false);
-  entry.PutParentId(parent_id);
-
-  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);
 
   // 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::CreateTombstone(const std::string& name,
+                                          ModelType model_type) {
+  WriteTransaction trans(FROM_HERE, UNITTEST, directory_);
+
+  // 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();
+
+  MutableEntry entry(&trans, syncable::CREATE, model_type, parent_id, name);
+  if (!entry.good()) {
+    NOTREACHED();
+    return syncable::kInvalidMetaHandle;
+  }
+
+  PopulateEntry(parent_id, name, model_type, &entry);
+  entry.PutIsDel(true);
+  entry.PutServerIsDel(true);
+  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));
@@ skipping 123 matching lines @@
     NOTREACHED();
     return false;
   }
   return entry.GetIsUnappliedUpdate();
 }
 
 int64_t TestEntryFactory::GetNextRevision() {
   return next_revision_++;
 }
 
+void TestEntryFactory::PopulateEntry(const syncable::Id& parent_id,
+                                     const std::string& name,
+                                     ModelType model_type,
+                                     MutableEntry* entry) {
+  syncable::Id item_id(TestIdFactory::MakeServer(name));
+  int64_t version = GetNextRevision();
+  base::Time now = base::Time::Now();
+
+  entry->PutId(item_id);
+  entry->PutCtime(now);
+  entry->PutMtime(now);
+  entry->PutUniqueClientTag(GenerateSyncableHash(model_type, name));
+  entry->PutBaseVersion(version);
+  entry->PutIsUnsynced(false);
+  entry->PutNonUniqueName(name);
+  entry->PutIsDir(false);
+  entry->PutIsDel(false);
+  entry->PutParentId(parent_id);
+
+  entry->PutServerCtime(now);
+  entry->PutServerMtime(now);
+  entry->PutServerVersion(version);
+  entry->PutIsUnappliedUpdate(false);
+  entry->PutServerNonUniqueName(name);
+  entry->PutServerParentId(parent_id);
+  entry->PutServerIsDir(false);
+  entry->PutServerIsDel(false);
+}
+
 }  // namespace syncer