Update next_id when loading sync DB

sync/syncable/syncable_unittest.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 <string>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/location.h"
@@ skipping 502 matching lines @@
                      bool is_del);
 
   // When a directory is saved then loaded from disk, it will pass through
   // DropDeletedEntries().  This will remove some entries from the directory.
   // This function is intended to simulate that process.
   //
   // WARNING: The directory will be deleted by this operation.  You should
   // not have any pointers to the directory (open transactions included)
   // when you call this.
   DirOpenResult SimulateSaveAndReloadDir();
+
+  // This function will close and re-open the directory without saving any
+  // pending changes.  This is intended to simulate the recovery from a crash
+  // scenario.  The same warnings for SimulateSaveAndReloadDir apply here.
+  DirOpenResult SimulateCrashAndReloadDir();
+
+ private:
+  // A helper function for Simulate{Save,Crash}AndReloadDir.
+  DirOpenResult ReloadDirImpl();
 };
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsMetahandlesToPurge) {
   const int metas_to_create = 50;
   MetahandleSet expected_purges;
   MetahandleSet all_handles;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir_.get());
     for (int i = 0; i < metas_to_create; i++) {
       MutableEntry e(&trans, CREATE, trans.root_id(), "foo");
@@ skipping 721 matching lines @@
     ChangeEntryIDAndUpdateChildren(&trans, &parent, id_factory.NewServerId());
     parent.Put(IS_UNSYNCED, false);
     parent.Put(BASE_VERSION, 1);
     parent.Put(SERVER_VERSION, 1);
   }
 
   // Final check for validity.
   EXPECT_EQ(OPENED, SimulateSaveAndReloadDir());
 }
 
+// Ask the directory to generate a unique ID.  Close and re-open the database
+// without saving, then ask for another unique ID.  Verify IDs are not reused.
+// This scenario simulates a crash within the first few seconds of operation.
+TEST_F(SyncableDirectoryTest, LocalIdReuseTest) {
+  Id pre_crash_id = dir_->NextId();
+  SimulateCrashAndReloadDir();
+  Id post_crash_id = dir_->NextId();
+  EXPECT_NE(pre_crash_id, post_crash_id);
+}
+
+// Ask the directory to generate a unique ID.  Save the directory.  Close and
+// re-open the database without saving, then ask for another unique ID.  Verify
+// IDs are not reused.  This scenario simulates a steady-state crash.
+TEST_F(SyncableDirectoryTest, LocalIdReuseTestWithSave) {
+  Id pre_crash_id = dir_->NextId();
+  dir_->SaveChanges();
+  SimulateCrashAndReloadDir();
+  Id post_crash_id = dir_->NextId();
+  EXPECT_NE(pre_crash_id, post_crash_id);
+}
+
 // Ensure that the unsynced, is_del and server unkown entries that may have been
 // left in the database by old clients will be deleted when we open the old
 // database.
 TEST_F(SyncableDirectoryTest, OldClientLeftUnsyncedDeletedLocalItem) {
   // We must create an entry with the offending properties.  This is done with
   // some abuse of the MutableEntry's API; it doesn't expect us to modify an
   // item after it is deleted.  If this hack becomes impractical we will need to
   // find a new way to simulate this scenario.
 
   TestIdFactory id_factory;
@@ skipping 440 matching lines @@
     ASSERT_TRUE(name == e.Get(NON_UNIQUE_NAME));
   ASSERT_TRUE(base_version == e.Get(BASE_VERSION));
   ASSERT_TRUE(server_version == e.Get(SERVER_VERSION));
   ASSERT_TRUE(is_del == e.Get(IS_DEL));
 }
 
 DirOpenResult SyncableDirectoryTest::SimulateSaveAndReloadDir() {
   if (!dir_->SaveChanges())
     return FAILED_IN_UNITTEST;
 
+  return ReloadDirImpl();
+}
+
+DirOpenResult SyncableDirectoryTest::SimulateCrashAndReloadDir() {
+  return ReloadDirImpl();
+}
+
+DirOpenResult SyncableDirectoryTest::ReloadDirImpl() {
   // Do some tricky things to preserve the backing store.
   DirectoryBackingStore* saved_store = dir_->store_.release();
 
   // Close the current directory.
   dir_->Close();
   dir_.reset();
 
   dir_.reset(new Directory(&encryptor_, &handler_, NULL, saved_store));
   DirOpenResult result = dir_->OpenImpl(kName, &delegate_,
                                         NullTransactionObserver());
@@ skipping 206 matching lines @@
   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 }
 
 }  // namespace
 }  // namespace syncable
 }  // namespace syncer