[Sync] Add keystore migration conflict support.

sync/internal_api/test/test_entry_factory.cc

 // Copyright (c) 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 "sync/syncable/directory.h"
+#include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
+#include "sync/syncable/read_transaction.h"
 #include "sync/syncable/syncable_id.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/test/engine/test_id_factory.h"
 
 using std::string;
 
 namespace syncer {
 
 using syncable::Id;
 using syncable::MutableEntry;
@@ skipping 16 matching lines @@
   DCHECK(entry.good());
   entry.Put(syncable::SERVER_VERSION, GetNextRevision());
   entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
 
   entry.Put(syncable::SERVER_NON_UNIQUE_NAME, item_id);
   entry.Put(syncable::SERVER_PARENT_ID, Id::CreateFromServerId(parent_id));
   entry.Put(syncable::SERVER_IS_DIR, true);
   entry.Put(syncable::SERVER_SPECIFICS, specifics);
 }
 
-void TestEntryFactory::CreateUnappliedNewItem(
-                            const string& item_id,
-                            const sync_pb::EntitySpecifics& specifics,
-                            bool is_unique) {
+int64 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));
   DCHECK(entry.good());
   entry.Put(syncable::SERVER_VERSION, GetNextRevision());
   entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
   entry.Put(syncable::SERVER_NON_UNIQUE_NAME, item_id);
   entry.Put(syncable::SERVER_PARENT_ID, syncable::GetNullId());
   entry.Put(syncable::SERVER_IS_DIR, false);
   entry.Put(syncable::SERVER_SPECIFICS, specifics);
   if (is_unique)  // For top-level nodes.
     entry.Put(syncable::UNIQUE_SERVER_TAG, item_id);
+  return entry.Get(syncable::META_HANDLE);
 }
 
 void TestEntryFactory::CreateUnsyncedItem(
     const Id& item_id,
     const Id& parent_id,
     const string& name,
     bool is_folder,
     ModelType model_type,
     int64* metahandle_out) {
   WriteTransaction trans(FROM_HERE, UNITTEST, directory_);
@@ skipping 81 matching lines @@
   entry.Put(syncable::SERVER_NON_UNIQUE_NAME, "X");
   entry.Put(syncable::SERVER_PARENT_ID, TestIdFactory::MakeServer("Y"));
   entry.Put(syncable::SERVER_IS_DIR, is_folder);
   entry.Put(syncable::SERVER_IS_DEL, false);
   entry.Put(syncable::SERVER_SPECIFICS, default_specifics);
   entry.Put(syncable::SERVER_PARENT_ID, parent_id);
 
   return entry.Get(syncable::META_HANDLE);
 }
 
+bool TestEntryFactory::SetSpecificsForItem(
+    int64 meta_handle,
+    SpecificsType specifics_type,
+    const sync_pb::EntitySpecifics specifics) {
+  WriteTransaction trans(FROM_HERE, UNITTEST, directory_);
+  MutableEntry entry(&trans, syncable::GET_BY_HANDLE, meta_handle);
+  if (!entry.good()) {
+    return false;
+  }
+  if (specifics_type == SERVER_SPECIFICS) {
+    entry.Put(syncable::SERVER_SPECIFICS, specifics);
+    entry.Put(syncable::IS_UNAPPLIED_UPDATE, true);
+  } else {
+    entry.Put(syncable::SPECIFICS, specifics);
+    entry.Put(syncable::IS_UNSYNCED, true);
+  }
+  return true;
+}
+
+const sync_pb::EntitySpecifics& TestEntryFactory::GetSpecificsForItem(
+    int64 meta_handle,
+    SpecificsType specifics_type) const {
+  syncable::ReadTransaction trans(FROM_HERE, directory_);
+  syncable::Entry entry(&trans, syncable::GET_BY_HANDLE, meta_handle);
+  if (!entry.good()) {

[rlarocque, 2012/09/13 22:10:51]

DCHECK() instead?

[Nicolas Zea, 2012/09/13 22:50:14]

Done.

+    NOTREACHED();
+  }
+  if (specifics_type == SERVER_SPECIFICS) {

[rlarocque, 2012/09/13 22:10:51]

Whereas the current definition allows you to reuse ~3 lines of code, I think it
would make sense to have two different functions for this:

GetLocalSpecificsForItem() and GetServerSpecificsForItem().

That way you wouldn't need the flag or this if statement.  

I'm assuming no one will ever want to pass in a non-literal 'specifics_type'
value to this function.

[Nicolas Zea, 2012/09/13 22:50:14]

Done (same for SetSpecificsForItem).

+    return entry.Get(syncable::SERVER_SPECIFICS);
+  } else {
+    return entry.Get(syncable::SPECIFICS);
+  }
+}
+
+bool TestEntryFactory::GetIsUnsyncedForItem(int64 meta_handle) const {
+  syncable::ReadTransaction trans(FROM_HERE, directory_);
+  syncable::Entry entry(&trans, syncable::GET_BY_HANDLE, meta_handle);
+  if (!entry.good()) {
+    NOTREACHED();
+    return false;
+  }
+  return entry.Get(syncable::IS_UNSYNCED);
+}
+
+bool TestEntryFactory::GetIsUnappliedForItem(int64 meta_handle) const {
+  syncable::ReadTransaction trans(FROM_HERE, directory_);
+  syncable::Entry entry(&trans, syncable::GET_BY_HANDLE, meta_handle);
+  if (!entry.good()) {
+    NOTREACHED();
+    return false;
+  }
+  return entry.Get(syncable::IS_UNAPPLIED_UPDATE);
+}
+
 int64 TestEntryFactory::GetNextRevision() {
   return next_revision_++;
 }
 
 }  // namespace syncer