Sync: Avoid 3 passes over SyncDarta DB when loading the directory from the disk

sync/syncable/directory_backing_store_unittest.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 "testing/gtest/include/gtest/gtest.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 28 matching lines @@
     return "nick@chromium.org";
   }
 
   base::FilePath GetDatabasePath() {
     return temp_dir_.path().Append(Directory::kSyncDatabaseFilename);
   }
 
   static bool LoadAndIgnoreReturnedData(DirectoryBackingStore *dbs) {
     Directory::MetahandlesMap tmp_handles_map;
     JournalIndex  delete_journals;
+    MetahandleSet metahandles_to_purge;
     STLValueDeleter<Directory::MetahandlesMap> deleter(&tmp_handles_map);
     Directory::KernelLoadInfo kernel_load_info;
-    return dbs->Load(&tmp_handles_map, &delete_journals, &kernel_load_info) ==
-        OPENED;
+    return dbs->Load(&tmp_handles_map, &delete_journals, &metahandles_to_purge,
+                     &kernel_load_info) == OPENED;
   }
 
   void SetUpVersion67Database(sql::Connection* connection);
   void SetUpVersion68Database(sql::Connection* connection);
   void SetUpVersion69Database(sql::Connection* connection);
   void SetUpVersion70Database(sql::Connection* connection);
   void SetUpVersion71Database(sql::Connection* connection);
   void SetUpVersion72Database(sql::Connection* connection);
   void SetUpVersion73Database(sql::Connection* connection);
   void SetUpVersion74Database(sql::Connection* connection);
@@ skipping 3132 matching lines @@
 
   scoped_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_FALSE(dbs->needs_column_refresh_);
   ASSERT_TRUE(dbs->MigrateVersion78To79());
   ASSERT_EQ(79, dbs->GetVersion());
   ASSERT_FALSE(dbs->needs_column_refresh_);
 
   // Ensure the next_id has been incremented.
   Directory::MetahandlesMap handles_map;
-  JournalIndex  delete_journals;;
+  JournalIndex delete_journals;
+  MetahandleSet metahandles_to_purge;
   STLValueDeleter<Directory::MetahandlesMap> deleter(&handles_map);
   Directory::KernelLoadInfo load_info;
 
   s.Clear();
-  ASSERT_TRUE(dbs->Load(&handles_map, &delete_journals, &load_info));
+  ASSERT_TRUE(dbs->Load(&handles_map, &delete_journals, &metahandles_to_purge,
+                        &load_info));
   EXPECT_LE(load_info.kernel_info.next_id, kInitialNextId - 65536);
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion79To80) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   SetUpVersion79Database(&connection);
 
   scoped_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   ASSERT_FALSE(dbs->needs_column_refresh_);
   ASSERT_TRUE(dbs->MigrateVersion79To80());
   ASSERT_EQ(80, dbs->GetVersion());
   ASSERT_FALSE(dbs->needs_column_refresh_);
 
   // Ensure the bag_of_chips has been set.
   Directory::MetahandlesMap handles_map;
-  JournalIndex  delete_journals;;
+  JournalIndex delete_journals;
+  MetahandleSet metahandles_to_purge;
   STLValueDeleter<Directory::MetahandlesMap> deleter(&handles_map);
   Directory::KernelLoadInfo load_info;
 
-  ASSERT_TRUE(dbs->Load(&handles_map, &delete_journals, &load_info));
+  ASSERT_TRUE(dbs->Load(&handles_map, &delete_journals, &metahandles_to_purge,
+                        &load_info));
   // Check that the initial value is the serialization of an empty ChipBag.
   sync_pb::ChipBag chip_bag;
   std::string serialized_chip_bag;
   ASSERT_TRUE(chip_bag.SerializeToString(&serialized_chip_bag));
   EXPECT_EQ(serialized_chip_bag, load_info.kernel_info.bag_of_chips);
 }
 
 TEST_F(DirectoryBackingStoreTest, MigrateVersion80To81) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
@@ skipping 188 matching lines @@
   // Insert row with bad position.
   sql::Statement s(connection.GetUniqueStatement(
       "INSERT INTO metas "
       "( id, metahandle, is_dir, ctime, mtime,"
       "  unique_position, server_unique_position) "
       "VALUES('c-invalid', 9999, 1, 0, 0, 'BAD_POS', 'BAD_POS')"));
   ASSERT_TRUE(s.Run());
 
   // Trying to unpack this entry should signal that the DB is corrupted.
   Directory::MetahandlesMap handles_map;
-  JournalIndex  delete_journals;;
+  JournalIndex delete_journals;
+  MetahandleSet metahandles_to_purge;
   STLValueDeleter<Directory::MetahandlesMap> deleter(&handles_map);
   Directory::KernelLoadInfo kernel_load_info;
   ASSERT_EQ(FAILED_DATABASE_CORRUPT,
-            dbs->Load(&handles_map, &delete_journals, &kernel_load_info));
+            dbs->Load(&handles_map, &delete_journals, &metahandles_to_purge,
+                      &kernel_load_info));
 }
 
 TEST_P(MigrationTest, ToCurrentVersion) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
   switch (GetParam()) {
     case 67:
       SetUpVersion67Database(&connection);
       break;
     case 68:
@@ skipping 66 matching lines @@
       // If you see this error, it may mean that you've increased the
       // database version number but you haven't finished adding unit tests
       // for the database migration code.  You need to need to supply a
       // SetUpVersionYDatabase function with a dump of the test database
       // at the new schema.  See the MigrateToLatestAndDump test case.
       FAIL() << "Need to supply database dump for version " << GetParam();
   }
 
   syncable::Directory::KernelLoadInfo dir_info;
   Directory::MetahandlesMap handles_map;
-  JournalIndex  delete_journals;;
+  JournalIndex delete_journals;
+  MetahandleSet metahandles_to_purge;
   STLValueDeleter<Directory::MetahandlesMap> index_deleter(&handles_map);
 
   {
     scoped_ptr<TestDirectoryBackingStore> dbs(
         new TestDirectoryBackingStore(GetUsername(), &connection));
-    ASSERT_EQ(OPENED, dbs->Load(&handles_map, &delete_journals, &dir_info));
+    ASSERT_EQ(OPENED, dbs->Load(&handles_map, &delete_journals,
+                                &metahandles_to_purge, &dir_info));
+    if (!metahandles_to_purge.empty())
+      dbs->DeleteEntries(metahandles_to_purge);
     ASSERT_FALSE(dbs->needs_column_refresh_);
     ASSERT_EQ(kCurrentDBVersion, dbs->GetVersion());
   }
 
   // Columns deleted in Version 67.
   ASSERT_FALSE(connection.DoesColumnExist("metas", "name"));
   ASSERT_FALSE(connection.DoesColumnExist("metas", "unsanitized_name"));
   ASSERT_FALSE(connection.DoesColumnExist("metas", "server_name"));
 
   // Columns added in Version 68.
@@ skipping 347 matching lines @@
 
 TEST_F(DirectoryBackingStoreTest, DeleteEntries) {
   sql::Connection connection;
   ASSERT_TRUE(connection.OpenInMemory());
 
   SetUpCurrentDatabaseAndCheckVersion(&connection);
   scoped_ptr<TestDirectoryBackingStore> dbs(
       new TestDirectoryBackingStore(GetUsername(), &connection));
   Directory::MetahandlesMap handles_map;
   JournalIndex  delete_journals;
+  MetahandleSet metahandles_to_purge;
   Directory::KernelLoadInfo kernel_load_info;
   STLValueDeleter<Directory::MetahandlesMap> index_deleter(&handles_map);
 
-  dbs->Load(&handles_map, &delete_journals, &kernel_load_info);
+  dbs->Load(&handles_map, &delete_journals, &metahandles_to_purge,
+            &kernel_load_info);
   size_t initial_size = handles_map.size();
   ASSERT_LT(0U, initial_size) << "Test requires handles_map to delete.";
   int64 first_to_die = handles_map.begin()->second->ref(META_HANDLE);
   MetahandleSet to_delete;
   to_delete.insert(first_to_die);
-  EXPECT_TRUE(dbs->DeleteEntries(TestDirectoryBackingStore::METAS_TABLE,
-                                 to_delete));
+  EXPECT_TRUE(dbs->DeleteEntries(to_delete));
 
   STLDeleteValues(&handles_map);
-  dbs->LoadEntries(&handles_map);
+  metahandles_to_purge.clear();
+  dbs->LoadEntries(&handles_map, &metahandles_to_purge);
 
   EXPECT_EQ(initial_size - 1, handles_map.size());
   bool delete_failed = false;
   for (Directory::MetahandlesMap::iterator it = handles_map.begin();
        it != handles_map.end(); ++it) {
     if (it->first == first_to_die) {
       delete_failed = true;
       break;
     }
   }
   EXPECT_FALSE(delete_failed);
 
   to_delete.clear();
   for (Directory::MetahandlesMap::iterator it = handles_map.begin();
        it != handles_map.end(); ++it) {
     to_delete.insert(it->first);
   }
 
-  EXPECT_TRUE(dbs->DeleteEntries(TestDirectoryBackingStore::METAS_TABLE,
-                                 to_delete));
+  EXPECT_TRUE(dbs->DeleteEntries(to_delete));
 
   STLDeleteValues(&handles_map);
-  dbs->LoadEntries(&handles_map);
+  metahandles_to_purge.clear();
+  dbs->LoadEntries(&handles_map, &metahandles_to_purge);
   EXPECT_EQ(0U, handles_map.size());
 }
 
 TEST_F(DirectoryBackingStoreTest, GenerateCacheGUID) {
   const std::string& guid1 = TestDirectoryBackingStore::GenerateCacheGUID();
   const std::string& guid2 = TestDirectoryBackingStore::GenerateCacheGUID();
   EXPECT_EQ(24U, guid1.size());
   EXPECT_EQ(24U, guid2.size());
   // In theory this test can fail, but it won't before the universe
   // dies of heat death.
   EXPECT_NE(guid1, guid2);
 }
 
 }  // namespace syncable
 }  // namespace syncer