[SyncFS] Test MetadataDatabaseTest using both on-memory and on-disk indexes

chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc

 // Copyright 2013 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 "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 149 matching lines @@
     ExpectEquivalent(*left_itr, *right_itr);
     ++left_itr;
     ++right_itr;
   }
 }
 
 base::FilePath CreateNormalizedPath(const base::FilePath::StringType& path) {
   return base::FilePath(path).NormalizePathSeparators();
 }
 
+struct IndexType {
+  bool enable_on_disk;
+  const char* scope;
+} index_types[] = {
+  {false, "Using index on memory"},
+  {true, "Using index on disk"}
+};
+
 }  // namespace
 
 class MetadataDatabaseTest : public testing::Test {
  public:
   MetadataDatabaseTest()
       : current_change_id_(kInitialChangeID),
         next_tracker_id_(kSyncRootTrackerID + 1),
         next_file_id_number_(1),
         next_md5_sequence_number_(1) {}
 
   virtual ~MetadataDatabaseTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  // TODO(peria): Change these methods to SetUp() and TearDown(),
+  // after deleting on-memory index.
+  void SetUpEnv() {
     ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
   }
-
-  virtual void TearDown() OVERRIDE { DropDatabase(); }
+  void TearDownEnv() {
+    DropDatabase();
+    in_memory_env_.reset();
+    EXPECT_TRUE(database_dir_.Delete());
+  }
 
  protected:
   std::string GenerateFileID() {
     return "file_id_" + base::Int64ToString(next_file_id_number_++);
   }
 
   int64 GetTrackerIDByFileID(const std::string& file_id) {
     TrackerIDSet trackers;
     if (metadata_database_->FindTrackersByFileID(file_id, &trackers)) {
       EXPECT_FALSE(trackers.empty());
       return *trackers.begin();
     }
     return 0;
   }
 
-  SyncStatusCode InitializeMetadataDatabase() {
+  SyncStatusCode InitializeMetadataDatabase(bool enable_on_disk_index) {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    MetadataDatabase::Create(base::ThreadTaskRunnerHandle::Get(),
-                             database_dir_.path(),
-                             in_memory_env_.get(),
-                             CreateResultReceiver(&status,
-                                                  &metadata_database_));
+    MetadataDatabase::CreateOnWorkerForTesting(
+        base::ThreadTaskRunnerHandle::Get(),
+        database_dir_.path(),
+        enable_on_disk_index,
+        in_memory_env_.get(),
+        CreateResultReceiver(&status, &metadata_database_));
     message_loop_.RunUntilIdle();
     return status;
   }
 
   void DropDatabase() {
     metadata_database_.reset();
     message_loop_.RunUntilIdle();
   }
 
   void SetUpDatabaseByTrackedFiles(const TrackedFile** tracked_files,
@@ skipping 428 matching lines @@
 
   int64 current_change_id_;
   int64 next_tracker_id_;
   int64 next_file_id_number_;
   int64 next_md5_sequence_number_;
 
   DISALLOW_COPY_AND_ASSIGN(MetadataDatabaseTest);
 };
 
 TEST_F(MetadataDatabaseTest, InitializationTest_Empty) {
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-  DropDatabase();
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-
-  DropDatabase();
-
-  scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
-  db->Put(kServiceMetadataKey, "Unparsable string");
-  EXPECT_TRUE(db->Commit().ok());
-  db.reset();
-
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
+  for (size_t i = 0; i < arraysize(index_types); ++i) {

[tzik, 2014/09/09 08:29:50]

Could you split these tests to two?

[peria, 2014/09/10 05:40:12]

Used parameterized test.

+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+    DropDatabase();
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+
+    DropDatabase();
+
+    scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
+    db->Put(kServiceMetadataKey, "Unparsable string");
+    EXPECT_TRUE(db->Commit().ok());
+    db.reset();
+
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+
+    TearDownEnv();
+  }
 }
 
 TEST_F(MetadataDatabaseTest, InitializationTest_SimpleTree) {
-  TrackedFile sync_root(CreateTrackedSyncRoot());
-  TrackedFile app_root(CreateTrackedFolder(sync_root, "app_id"));
-  app_root.tracker.set_app_id(app_root.metadata.details().title());
-  app_root.tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
-
-  TrackedFile file(CreateTrackedFile(app_root, "file"));
-  TrackedFile folder(CreateTrackedFolder(app_root, "folder"));
-  TrackedFile file_in_folder(CreateTrackedFile(folder, "file_in_folder"));
-  TrackedFile orphaned_file(CreateTrackedFile(sync_root, "orphaned_file"));
-  orphaned_file.metadata.mutable_details()->clear_parent_folder_ids();
-  orphaned_file.tracker.set_parent_tracker_id(0);
-
-  const TrackedFile* tracked_files[] = {
-    &sync_root, &app_root, &file, &folder, &file_in_folder, &orphaned_file
-  };
-
-  SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-
-  orphaned_file.should_be_absent = true;
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+  for (size_t i = 0; i < arraysize(index_types); ++i) {
+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    TrackedFile sync_root(CreateTrackedSyncRoot());
+    TrackedFile app_root(CreateTrackedFolder(sync_root, "app_id"));
+    app_root.tracker.set_app_id(app_root.metadata.details().title());
+    app_root.tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
+
+    TrackedFile file(CreateTrackedFile(app_root, "file"));
+    TrackedFile folder(CreateTrackedFolder(app_root, "folder"));
+    TrackedFile file_in_folder(CreateTrackedFile(folder, "file_in_folder"));
+    TrackedFile orphaned_file(CreateTrackedFile(sync_root, "orphaned_file"));
+    orphaned_file.metadata.mutable_details()->clear_parent_folder_ids();
+    orphaned_file.tracker.set_parent_tracker_id(0);
+
+    const TrackedFile* tracked_files[] = {
+      &sync_root, &app_root, &file, &folder, &file_in_folder, &orphaned_file
+    };
+
+    SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+
+    orphaned_file.should_be_absent = true;
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+
+    TearDownEnv();
+  }
 }
 
 TEST_F(MetadataDatabaseTest, AppManagementTest) {
-  TrackedFile sync_root(CreateTrackedSyncRoot());
-  TrackedFile app_root(CreateTrackedFolder(sync_root, "app_id"));
-  app_root.tracker.set_app_id(app_root.metadata.details().title());
-  app_root.tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
-
-  TrackedFile file(CreateTrackedFile(app_root, "file"));
-  TrackedFile folder(CreateTrackedFolder(sync_root, "folder"));
-  folder.tracker.set_active(false);
-
-  const TrackedFile* tracked_files[] = {
-    &sync_root, &app_root, &file, &folder,
-  };
-  SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-
-  folder.tracker.set_app_id("foo");
-  EXPECT_EQ(SYNC_STATUS_OK, RegisterApp(
-      folder.tracker.app_id(), folder.metadata.file_id()));
-  folder.tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
-  folder.tracker.set_active(true);
-  folder.tracker.set_dirty(true);
-  folder.tracker.set_needs_folder_listing(true);
-  VerifyTrackedFile(folder);
-  VerifyReloadConsistency();
-
-  EXPECT_EQ(SYNC_STATUS_OK, DisableApp(folder.tracker.app_id()));
-  folder.tracker.set_tracker_kind(TRACKER_KIND_DISABLED_APP_ROOT);
-  VerifyTrackedFile(folder);
-  VerifyReloadConsistency();
-
-  EXPECT_EQ(SYNC_STATUS_OK, EnableApp(folder.tracker.app_id()));
-  folder.tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
-  VerifyTrackedFile(folder);
-  VerifyReloadConsistency();
-
-  EXPECT_EQ(SYNC_STATUS_OK, UnregisterApp(folder.tracker.app_id()));
-  folder.tracker.set_app_id(std::string());
-  folder.tracker.set_tracker_kind(TRACKER_KIND_REGULAR);
-  folder.tracker.set_active(false);
-  VerifyTrackedFile(folder);
-  VerifyReloadConsistency();
-
-  EXPECT_EQ(SYNC_STATUS_OK, UnregisterApp(app_root.tracker.app_id()));
-  app_root.tracker.set_app_id(std::string());
-  app_root.tracker.set_tracker_kind(TRACKER_KIND_REGULAR);
-  app_root.tracker.set_active(false);
-  app_root.tracker.set_dirty(true);
-  file.should_be_absent = true;
-  VerifyTrackedFile(app_root);
-  VerifyTrackedFile(file);
-  VerifyReloadConsistency();
+  for (size_t i = 0; i < arraysize(index_types); ++i) {
+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    TrackedFile sync_root(CreateTrackedSyncRoot());
+    TrackedFile app_root(CreateTrackedFolder(sync_root, "app_id"));
+    app_root.tracker.set_app_id(app_root.metadata.details().title());
+    app_root.tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
+
+    TrackedFile file(CreateTrackedFile(app_root, "file"));
+    TrackedFile folder(CreateTrackedFolder(sync_root, "folder"));
+    folder.tracker.set_active(false);
+
+    const TrackedFile* tracked_files[] = {
+      &sync_root, &app_root, &file, &folder,
+    };
+    SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+
+    folder.tracker.set_app_id("foo");
+    EXPECT_EQ(SYNC_STATUS_OK, RegisterApp(
+        folder.tracker.app_id(), folder.metadata.file_id()));
+    folder.tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
+    folder.tracker.set_active(true);
+    folder.tracker.set_dirty(true);
+    folder.tracker.set_needs_folder_listing(true);
+    VerifyTrackedFile(folder);
+    VerifyReloadConsistency();
+
+    EXPECT_EQ(SYNC_STATUS_OK, DisableApp(folder.tracker.app_id()));
+    folder.tracker.set_tracker_kind(TRACKER_KIND_DISABLED_APP_ROOT);
+    VerifyTrackedFile(folder);
+    VerifyReloadConsistency();
+
+    EXPECT_EQ(SYNC_STATUS_OK, EnableApp(folder.tracker.app_id()));
+    folder.tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
+    VerifyTrackedFile(folder);
+    VerifyReloadConsistency();
+
+    EXPECT_EQ(SYNC_STATUS_OK, UnregisterApp(folder.tracker.app_id()));
+    folder.tracker.set_app_id(std::string());
+    folder.tracker.set_tracker_kind(TRACKER_KIND_REGULAR);
+    folder.tracker.set_active(false);
+    VerifyTrackedFile(folder);
+    VerifyReloadConsistency();
+
+    EXPECT_EQ(SYNC_STATUS_OK, UnregisterApp(app_root.tracker.app_id()));
+    app_root.tracker.set_app_id(std::string());
+    app_root.tracker.set_tracker_kind(TRACKER_KIND_REGULAR);
+    app_root.tracker.set_active(false);
+    app_root.tracker.set_dirty(true);
+    file.should_be_absent = true;
+    VerifyTrackedFile(app_root);
+    VerifyTrackedFile(file);
+    VerifyReloadConsistency();
+
+    TearDownEnv();
+  }
 }
 
 TEST_F(MetadataDatabaseTest, BuildPathTest) {
-  FileMetadata sync_root(CreateSyncRootMetadata());
-  FileTracker sync_root_tracker(CreateSyncRootTracker(sync_root));
-
-  FileMetadata app_root(CreateFolderMetadata(sync_root, "app_id"));
-  FileTracker app_root_tracker(
-      CreateTracker(sync_root_tracker, app_root));
-  app_root_tracker.set_app_id(app_root.details().title());
-  app_root_tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
-
-  FileMetadata folder(CreateFolderMetadata(app_root, "folder"));
-  FileTracker folder_tracker(CreateTracker(app_root_tracker, folder));
-
-  FileMetadata file(CreateFileMetadata(folder, "file"));
-  FileTracker file_tracker(CreateTracker(folder_tracker, file));
-
-  FileMetadata inactive_folder(CreateFolderMetadata(app_root, "folder"));
-  FileTracker inactive_folder_tracker(CreateTracker(app_root_tracker,
-                                                    inactive_folder));
-  inactive_folder_tracker.set_active(false);
-
-  {
-    scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
-    ASSERT_TRUE(db);
-
-    EXPECT_TRUE(PutFileToDB(db.get(), sync_root).ok());
-    EXPECT_TRUE(PutTrackerToDB(db.get(), sync_root_tracker).ok());
-    EXPECT_TRUE(PutFileToDB(db.get(), app_root).ok());
-    EXPECT_TRUE(PutTrackerToDB(db.get(), app_root_tracker).ok());
-    EXPECT_TRUE(PutFileToDB(db.get(), folder).ok());
-    EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker).ok());
-    EXPECT_TRUE(PutFileToDB(db.get(), file).ok());
-    EXPECT_TRUE(PutTrackerToDB(db.get(), file_tracker).ok());
-  }
-
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-
-  base::FilePath path;
-  EXPECT_FALSE(metadata_database()->BuildPathForTracker(
-      sync_root_tracker.tracker_id(), &path));
-  EXPECT_TRUE(metadata_database()->BuildPathForTracker(
-      app_root_tracker.tracker_id(), &path));
-  EXPECT_EQ(base::FilePath(FPL("/")).NormalizePathSeparators(), path);
-  EXPECT_TRUE(metadata_database()->BuildPathForTracker(
-      file_tracker.tracker_id(), &path));
-  EXPECT_EQ(base::FilePath(FPL("/folder/file")).NormalizePathSeparators(),
-            path);
+  for (size_t i = 0; i < arraysize(index_types); ++i) {
+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    FileMetadata sync_root(CreateSyncRootMetadata());
+    FileTracker sync_root_tracker(CreateSyncRootTracker(sync_root));
+
+    FileMetadata app_root(CreateFolderMetadata(sync_root, "app_id"));
+    FileTracker app_root_tracker(
+        CreateTracker(sync_root_tracker, app_root));
+    app_root_tracker.set_app_id(app_root.details().title());
+    app_root_tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
+
+    FileMetadata folder(CreateFolderMetadata(app_root, "folder"));
+    FileTracker folder_tracker(CreateTracker(app_root_tracker, folder));
+
+    FileMetadata file(CreateFileMetadata(folder, "file"));
+    FileTracker file_tracker(CreateTracker(folder_tracker, file));
+
+    FileMetadata inactive_folder(CreateFolderMetadata(app_root, "folder"));
+    FileTracker inactive_folder_tracker(CreateTracker(app_root_tracker,
+                                                      inactive_folder));
+    inactive_folder_tracker.set_active(false);
+
+    {
+      scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
+      ASSERT_TRUE(db);
+
+      EXPECT_TRUE(PutFileToDB(db.get(), sync_root).ok());
+      EXPECT_TRUE(PutTrackerToDB(db.get(), sync_root_tracker).ok());
+      EXPECT_TRUE(PutFileToDB(db.get(), app_root).ok());
+      EXPECT_TRUE(PutTrackerToDB(db.get(), app_root_tracker).ok());
+      EXPECT_TRUE(PutFileToDB(db.get(), folder).ok());
+      EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker).ok());
+      EXPECT_TRUE(PutFileToDB(db.get(), file).ok());
+      EXPECT_TRUE(PutTrackerToDB(db.get(), file_tracker).ok());
+    }
+
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+
+    base::FilePath path;
+    EXPECT_FALSE(metadata_database()->BuildPathForTracker(
+        sync_root_tracker.tracker_id(), &path));
+    EXPECT_TRUE(metadata_database()->BuildPathForTracker(
+        app_root_tracker.tracker_id(), &path));
+    EXPECT_EQ(base::FilePath(FPL("/")).NormalizePathSeparators(), path);
+    EXPECT_TRUE(metadata_database()->BuildPathForTracker(
+        file_tracker.tracker_id(), &path));
+    EXPECT_EQ(base::FilePath(FPL("/folder/file")).NormalizePathSeparators(),
+              path);
+
+    TearDownEnv();
+  }
 }
 
 TEST_F(MetadataDatabaseTest, FindNearestActiveAncestorTest) {
-  const std::string kAppID = "app_id";
-
-  FileMetadata sync_root(CreateSyncRootMetadata());
-  FileTracker sync_root_tracker(CreateSyncRootTracker(sync_root));
-
-  FileMetadata app_root(CreateFolderMetadata(sync_root, kAppID));
-  FileTracker app_root_tracker(
-      CreateTracker(sync_root_tracker, app_root));
-  app_root_tracker.set_app_id(app_root.details().title());
-  app_root_tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
-
-  // Create directory structure like this: "/folder1/folder2/file"
-  FileMetadata folder1(CreateFolderMetadata(app_root, "folder1"));
-  FileTracker folder_tracker1(CreateTracker(app_root_tracker, folder1));
-  FileMetadata folder2(CreateFolderMetadata(folder1, "folder2"));
-  FileTracker folder_tracker2(CreateTracker(folder_tracker1, folder2));
-  FileMetadata file(CreateFileMetadata(folder2, "file"));
-  FileTracker file_tracker(CreateTracker(folder_tracker2, file));
-
-  FileMetadata inactive_folder(CreateFolderMetadata(app_root, "folder1"));
-  FileTracker inactive_folder_tracker(CreateTracker(app_root_tracker,
-                                                    inactive_folder));
-  inactive_folder_tracker.set_active(false);
-
-  {
-    scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
-    ASSERT_TRUE(db);
-
-    EXPECT_TRUE(PutFileToDB(db.get(), sync_root).ok());
-    EXPECT_TRUE(PutTrackerToDB(db.get(), sync_root_tracker).ok());
-    EXPECT_TRUE(PutFileToDB(db.get(), app_root).ok());
-    EXPECT_TRUE(PutTrackerToDB(db.get(), app_root_tracker).ok());
-    EXPECT_TRUE(PutFileToDB(db.get(), folder1).ok());
-    EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker1).ok());
-    EXPECT_TRUE(PutFileToDB(db.get(), folder2).ok());
-    EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker2).ok());
-    EXPECT_TRUE(PutFileToDB(db.get(), file).ok());
-    EXPECT_TRUE(PutTrackerToDB(db.get(), file_tracker).ok());
-    EXPECT_TRUE(PutFileToDB(db.get(), inactive_folder).ok());
-    EXPECT_TRUE(PutTrackerToDB(db.get(), inactive_folder_tracker).ok());
-  }
-
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-
-  {
-    base::FilePath path;
-    FileTracker tracker;
-    EXPECT_FALSE(metadata_database()->FindNearestActiveAncestor(
-        "non_registered_app_id",
-        CreateNormalizedPath(FPL("folder1/folder2/file")),
-        &tracker, &path));
-  }
-
-  {
-    base::FilePath path;
-    FileTracker tracker;
-    EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
-        kAppID, CreateNormalizedPath(FPL("")), &tracker, &path));
-    EXPECT_EQ(app_root_tracker.tracker_id(), tracker.tracker_id());
-    EXPECT_EQ(CreateNormalizedPath(FPL("")), path);
-  }
-
-  {
-    base::FilePath path;
-    FileTracker tracker;
-    EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
-        kAppID, CreateNormalizedPath(FPL("folder1/folder2")),
-        &tracker, &path));
-    EXPECT_EQ(folder_tracker2.tracker_id(), tracker.tracker_id());
-    EXPECT_EQ(CreateNormalizedPath(FPL("folder1/folder2")), path);
-  }
-
-  {
-    base::FilePath path;
-    FileTracker tracker;
-    EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
-        kAppID, CreateNormalizedPath(FPL("folder1/folder2/file")),
-        &tracker, &path));
-    EXPECT_EQ(file_tracker.tracker_id(), tracker.tracker_id());
-    EXPECT_EQ(CreateNormalizedPath(FPL("folder1/folder2/file")), path);
-  }
-
-  {
-    base::FilePath path;
-    FileTracker tracker;
-    EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
-        kAppID,
-        CreateNormalizedPath(FPL("folder1/folder2/folder3/folder4/file")),
-        &tracker, &path));
-    EXPECT_EQ(folder_tracker2.tracker_id(), tracker.tracker_id());
-    EXPECT_EQ(CreateNormalizedPath(FPL("folder1/folder2")), path);
-  }
-
-  {
-    base::FilePath path;
-    FileTracker tracker;
-    EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
-        kAppID, CreateNormalizedPath(FPL("folder1/folder2/file/folder4/file")),
-        &tracker, &path));
-    EXPECT_EQ(folder_tracker2.tracker_id(), tracker.tracker_id());
-    EXPECT_EQ(CreateNormalizedPath(FPL("folder1/folder2")), path);
+  for (size_t i = 0; i < arraysize(index_types); ++i) {
+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    const std::string kAppID = "app_id";
+
+    FileMetadata sync_root(CreateSyncRootMetadata());
+    FileTracker sync_root_tracker(CreateSyncRootTracker(sync_root));
+
+    FileMetadata app_root(CreateFolderMetadata(sync_root, kAppID));
+    FileTracker app_root_tracker(
+        CreateTracker(sync_root_tracker, app_root));
+    app_root_tracker.set_app_id(app_root.details().title());
+    app_root_tracker.set_tracker_kind(TRACKER_KIND_APP_ROOT);
+
+    // Create directory structure like this: "/folder1/folder2/file"
+    FileMetadata folder1(CreateFolderMetadata(app_root, "folder1"));
+    FileTracker folder_tracker1(CreateTracker(app_root_tracker, folder1));
+    FileMetadata folder2(CreateFolderMetadata(folder1, "folder2"));
+    FileTracker folder_tracker2(CreateTracker(folder_tracker1, folder2));
+    FileMetadata file(CreateFileMetadata(folder2, "file"));
+    FileTracker file_tracker(CreateTracker(folder_tracker2, file));
+
+    FileMetadata inactive_folder(CreateFolderMetadata(app_root, "folder1"));
+    FileTracker inactive_folder_tracker(CreateTracker(app_root_tracker,
+                                                      inactive_folder));
+    inactive_folder_tracker.set_active(false);
+
+    {
+      scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
+      ASSERT_TRUE(db);
+
+      EXPECT_TRUE(PutFileToDB(db.get(), sync_root).ok());
+      EXPECT_TRUE(PutTrackerToDB(db.get(), sync_root_tracker).ok());
+      EXPECT_TRUE(PutFileToDB(db.get(), app_root).ok());
+      EXPECT_TRUE(PutTrackerToDB(db.get(), app_root_tracker).ok());
+      EXPECT_TRUE(PutFileToDB(db.get(), folder1).ok());
+      EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker1).ok());
+      EXPECT_TRUE(PutFileToDB(db.get(), folder2).ok());
+      EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker2).ok());
+      EXPECT_TRUE(PutFileToDB(db.get(), file).ok());
+      EXPECT_TRUE(PutTrackerToDB(db.get(), file_tracker).ok());
+      EXPECT_TRUE(PutFileToDB(db.get(), inactive_folder).ok());
+      EXPECT_TRUE(PutTrackerToDB(db.get(), inactive_folder_tracker).ok());
+    }
+
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+
+    {
+      base::FilePath path;
+      FileTracker tracker;
+      EXPECT_FALSE(metadata_database()->FindNearestActiveAncestor(
+          "non_registered_app_id",
+          CreateNormalizedPath(FPL("folder1/folder2/file")),
+          &tracker, &path));
+    }
+
+    {
+      base::FilePath path;
+      FileTracker tracker;
+      EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
+          kAppID, CreateNormalizedPath(FPL("")), &tracker, &path));
+      EXPECT_EQ(app_root_tracker.tracker_id(), tracker.tracker_id());
+      EXPECT_EQ(CreateNormalizedPath(FPL("")), path);
+    }
+
+    {
+      base::FilePath path;
+      FileTracker tracker;
+      EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
+          kAppID, CreateNormalizedPath(FPL("folder1/folder2")),
+          &tracker, &path));
+      EXPECT_EQ(folder_tracker2.tracker_id(), tracker.tracker_id());
+      EXPECT_EQ(CreateNormalizedPath(FPL("folder1/folder2")), path);
+    }
+
+    {
+      base::FilePath path;
+      FileTracker tracker;
+      EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
+          kAppID, CreateNormalizedPath(FPL("folder1/folder2/file")),
+          &tracker, &path));
+      EXPECT_EQ(file_tracker.tracker_id(), tracker.tracker_id());
+      EXPECT_EQ(CreateNormalizedPath(FPL("folder1/folder2/file")), path);
+    }
+
+    {
+      base::FilePath path;
+      FileTracker tracker;
+      EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
+          kAppID,
+          CreateNormalizedPath(FPL("folder1/folder2/folder3/folder4/file")),
+          &tracker, &path));
+      EXPECT_EQ(folder_tracker2.tracker_id(), tracker.tracker_id());
+      EXPECT_EQ(CreateNormalizedPath(FPL("folder1/folder2")), path);
+    }
+
+    {
+      base::FilePath path;
+      FileTracker tracker;
+      EXPECT_TRUE(metadata_database()->FindNearestActiveAncestor(
+          kAppID,
+          CreateNormalizedPath(FPL("folder1/folder2/file/folder4/file")),
+          &tracker, &path));
+      EXPECT_EQ(folder_tracker2.tracker_id(), tracker.tracker_id());
+      EXPECT_EQ(CreateNormalizedPath(FPL("folder1/folder2")), path);
+    }
+
+    TearDownEnv();
   }
 }
 
 TEST_F(MetadataDatabaseTest, UpdateByChangeListTest) {
-  TrackedFile sync_root(CreateTrackedSyncRoot());
-  TrackedFile app_root(CreateTrackedFolder(sync_root, "app_id"));
-  TrackedFile disabled_app_root(CreateTrackedFolder(sync_root, "disabled_app"));
-  TrackedFile file(CreateTrackedFile(app_root, "file"));
-  TrackedFile renamed_file(CreateTrackedFile(app_root, "to be renamed"));
-  TrackedFile folder(CreateTrackedFolder(app_root, "folder"));
-  TrackedFile reorganized_file(
-      CreateTrackedFile(app_root, "to be reorganized"));
-  TrackedFile updated_file(
-      CreateTrackedFile(app_root, "to be updated"));
-  TrackedFile noop_file(CreateTrackedFile(app_root, "has noop change"));
-  TrackedFile new_file(CreateTrackedFile(app_root, "to be added later"));
-  new_file.should_be_absent = true;
-
-  const TrackedFile* tracked_files[] = {
-    &sync_root, &app_root, &disabled_app_root,
-    &file, &renamed_file, &folder, &reorganized_file, &updated_file, &noop_file,
-    &new_file,
-  };
-
-  SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-
-  ApplyRenameChangeToMetadata("renamed", &renamed_file.metadata);
-  ApplyReorganizeChangeToMetadata(folder.metadata.file_id(),
-                                  &reorganized_file.metadata);
-  ApplyContentChangeToMetadata(&updated_file.metadata);
-
-  // Update change ID.
-  ApplyNoopChangeToMetadata(&noop_file.metadata);
-
-  ScopedVector<google_apis::ChangeResource> changes;
-  PushToChangeList(
-      CreateChangeResourceFromMetadata(renamed_file.metadata), &changes);
-  PushToChangeList(
-      CreateChangeResourceFromMetadata(reorganized_file.metadata), &changes);
-  PushToChangeList(
-      CreateChangeResourceFromMetadata(updated_file.metadata), &changes);
-  PushToChangeList(
-      CreateChangeResourceFromMetadata(noop_file.metadata), &changes);
-  PushToChangeList(
-      CreateChangeResourceFromMetadata(new_file.metadata), &changes);
-  EXPECT_EQ(SYNC_STATUS_OK, UpdateByChangeList(changes.Pass()));
-
-  renamed_file.tracker.set_dirty(true);
-  reorganized_file.tracker.set_dirty(true);
-  updated_file.tracker.set_dirty(true);
-  noop_file.tracker.set_dirty(true);
-  new_file.tracker.mutable_synced_details()->set_missing(true);
-  new_file.tracker.mutable_synced_details()->clear_md5();
-  new_file.tracker.set_active(false);
-  new_file.tracker.set_dirty(true);
-  ResetTrackerID(&new_file.tracker);
-  EXPECT_NE(0, new_file.tracker.tracker_id());
-
-  new_file.should_be_absent = false;
-
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-  VerifyReloadConsistency();
+  for (size_t i = 0; i < arraysize(index_types); ++i) {
+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    TrackedFile sync_root(CreateTrackedSyncRoot());
+    TrackedFile app_root(CreateTrackedFolder(sync_root, "app_id"));
+    TrackedFile disabled_app_root(
+        CreateTrackedFolder(sync_root, "disabled_app"));
+    TrackedFile file(CreateTrackedFile(app_root, "file"));
+    TrackedFile renamed_file(CreateTrackedFile(app_root, "to be renamed"));
+    TrackedFile folder(CreateTrackedFolder(app_root, "folder"));
+    TrackedFile reorganized_file(
+        CreateTrackedFile(app_root, "to be reorganized"));
+    TrackedFile updated_file(
+        CreateTrackedFile(app_root, "to be updated"));
+    TrackedFile noop_file(CreateTrackedFile(app_root, "has noop change"));
+    TrackedFile new_file(CreateTrackedFile(app_root, "to be added later"));
+    new_file.should_be_absent = true;
+
+    const TrackedFile* tracked_files[] = {
+      &sync_root, &app_root, &disabled_app_root,
+      &file, &renamed_file, &folder, &reorganized_file, &updated_file,
+      &noop_file, &new_file,
+    };
+
+    SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+
+    ApplyRenameChangeToMetadata("renamed", &renamed_file.metadata);
+    ApplyReorganizeChangeToMetadata(folder.metadata.file_id(),
+                                    &reorganized_file.metadata);
+    ApplyContentChangeToMetadata(&updated_file.metadata);
+
+    // Update change ID.
+    ApplyNoopChangeToMetadata(&noop_file.metadata);
+
+    ScopedVector<google_apis::ChangeResource> changes;
+    PushToChangeList(
+        CreateChangeResourceFromMetadata(renamed_file.metadata), &changes);
+    PushToChangeList(
+        CreateChangeResourceFromMetadata(reorganized_file.metadata), &changes);
+    PushToChangeList(
+        CreateChangeResourceFromMetadata(updated_file.metadata), &changes);
+    PushToChangeList(
+        CreateChangeResourceFromMetadata(noop_file.metadata), &changes);
+    PushToChangeList(
+        CreateChangeResourceFromMetadata(new_file.metadata), &changes);
+    EXPECT_EQ(SYNC_STATUS_OK, UpdateByChangeList(changes.Pass()));
+
+    renamed_file.tracker.set_dirty(true);
+    reorganized_file.tracker.set_dirty(true);
+    updated_file.tracker.set_dirty(true);
+    noop_file.tracker.set_dirty(true);
+    new_file.tracker.mutable_synced_details()->set_missing(true);
+    new_file.tracker.mutable_synced_details()->clear_md5();
+    new_file.tracker.set_active(false);
+    new_file.tracker.set_dirty(true);
+    ResetTrackerID(&new_file.tracker);
+    EXPECT_NE(0, new_file.tracker.tracker_id());
+
+    new_file.should_be_absent = false;
+
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+    VerifyReloadConsistency();
+
+    TearDownEnv();
+  }
 }
 
 TEST_F(MetadataDatabaseTest, PopulateFolderTest_RegularFolder) {
-  TrackedFile sync_root(CreateTrackedSyncRoot());
-  TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_id"));
-  app_root.tracker.set_app_id(app_root.metadata.details().title());
-
-  TrackedFile folder_to_populate(
-      CreateTrackedFolder(app_root, "folder_to_populate"));
-  folder_to_populate.tracker.set_needs_folder_listing(true);
-  folder_to_populate.tracker.set_dirty(true);
-
-  TrackedFile known_file(CreateTrackedFile(folder_to_populate, "known_file"));
-  TrackedFile new_file(CreateTrackedFile(folder_to_populate, "new_file"));
-  new_file.should_be_absent = true;
-
-  const TrackedFile* tracked_files[] = {
-    &sync_root, &app_root, &folder_to_populate, &known_file, &new_file
-  };
-
-  SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-
-  FileIDList listed_children;
-  listed_children.push_back(known_file.metadata.file_id());
-  listed_children.push_back(new_file.metadata.file_id());
-
-  EXPECT_EQ(SYNC_STATUS_OK,
-            PopulateFolder(folder_to_populate.metadata.file_id(),
-                           listed_children));
-
-  folder_to_populate.tracker.set_dirty(false);
-  folder_to_populate.tracker.set_needs_folder_listing(false);
-  ResetTrackerID(&new_file.tracker);
-  new_file.tracker.set_dirty(true);
-  new_file.tracker.set_active(false);
-  new_file.tracker.clear_synced_details();
-  new_file.should_be_absent = false;
-  new_file.tracker_only = true;
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-  VerifyReloadConsistency();
+  for (size_t i = 0; i < arraysize(index_types); ++i) {
+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    TrackedFile sync_root(CreateTrackedSyncRoot());
+    TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_id"));
+    app_root.tracker.set_app_id(app_root.metadata.details().title());
+
+    TrackedFile folder_to_populate(
+        CreateTrackedFolder(app_root, "folder_to_populate"));
+    folder_to_populate.tracker.set_needs_folder_listing(true);
+    folder_to_populate.tracker.set_dirty(true);
+
+    TrackedFile known_file(CreateTrackedFile(folder_to_populate, "known_file"));
+    TrackedFile new_file(CreateTrackedFile(folder_to_populate, "new_file"));
+    new_file.should_be_absent = true;
+
+    const TrackedFile* tracked_files[] = {
+      &sync_root, &app_root, &folder_to_populate, &known_file, &new_file
+    };
+
+    SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+
+    FileIDList listed_children;
+    listed_children.push_back(known_file.metadata.file_id());
+    listed_children.push_back(new_file.metadata.file_id());
+
+    EXPECT_EQ(SYNC_STATUS_OK,
+              PopulateFolder(folder_to_populate.metadata.file_id(),
+                             listed_children));
+
+    folder_to_populate.tracker.set_dirty(false);
+    folder_to_populate.tracker.set_needs_folder_listing(false);
+    ResetTrackerID(&new_file.tracker);
+    new_file.tracker.set_dirty(true);
+    new_file.tracker.set_active(false);
+    new_file.tracker.clear_synced_details();
+    new_file.should_be_absent = false;
+    new_file.tracker_only = true;
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+    VerifyReloadConsistency();
+
+    TearDownEnv();
+  }
 }
 
 TEST_F(MetadataDatabaseTest, PopulateFolderTest_InactiveFolder) {
-  TrackedFile sync_root(CreateTrackedSyncRoot());
-  TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_id"));
-
-  TrackedFile inactive_folder(CreateTrackedFolder(app_root, "inactive_folder"));
-  inactive_folder.tracker.set_active(false);
-  inactive_folder.tracker.set_dirty(true);
-
-  TrackedFile new_file(
-      CreateTrackedFile(inactive_folder, "file_in_inactive_folder"));
-  new_file.should_be_absent = true;
-
-  const TrackedFile* tracked_files[] = {
-    &sync_root, &app_root, &inactive_folder, &new_file,
-  };
-
-  SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-
-  FileIDList listed_children;
-  listed_children.push_back(new_file.metadata.file_id());
-
-  EXPECT_EQ(SYNC_STATUS_OK,
-            PopulateFolder(inactive_folder.metadata.file_id(),
-                           listed_children));
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-  VerifyReloadConsistency();
+  for (size_t i = 0; i < arraysize(index_types); ++i) {
+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    TrackedFile sync_root(CreateTrackedSyncRoot());
+    TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_id"));
+
+    TrackedFile inactive_folder(
+        CreateTrackedFolder(app_root, "inactive_folder"));
+    inactive_folder.tracker.set_active(false);
+    inactive_folder.tracker.set_dirty(true);
+
+    TrackedFile new_file(
+        CreateTrackedFile(inactive_folder, "file_in_inactive_folder"));
+    new_file.should_be_absent = true;
+
+    const TrackedFile* tracked_files[] = {
+      &sync_root, &app_root, &inactive_folder, &new_file,
+    };
+
+    SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+
+    FileIDList listed_children;
+    listed_children.push_back(new_file.metadata.file_id());
+
+    EXPECT_EQ(SYNC_STATUS_OK,
+              PopulateFolder(inactive_folder.metadata.file_id(),
+                             listed_children));
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+    VerifyReloadConsistency();
+
+    TearDownEnv();
+  }
 }
 
 TEST_F(MetadataDatabaseTest, PopulateFolderTest_DisabledAppRoot) {
-  TrackedFile sync_root(CreateTrackedSyncRoot());
-  TrackedFile disabled_app_root(
-      CreateTrackedAppRoot(sync_root, "disabled_app"));
-  disabled_app_root.tracker.set_dirty(true);
-  disabled_app_root.tracker.set_needs_folder_listing(true);
-
-  TrackedFile known_file(CreateTrackedFile(disabled_app_root, "known_file"));
-  TrackedFile file(CreateTrackedFile(disabled_app_root, "file"));
-  file.should_be_absent = true;
-
-  const TrackedFile* tracked_files[] = {
-    &sync_root, &disabled_app_root, &disabled_app_root, &known_file, &file,
-  };
-
-  SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-
-  FileIDList disabled_app_children;
-  disabled_app_children.push_back(file.metadata.file_id());
-  EXPECT_EQ(SYNC_STATUS_OK, PopulateFolder(
-      disabled_app_root.metadata.file_id(), disabled_app_children));
-  ResetTrackerID(&file.tracker);
-  file.tracker.clear_synced_details();
-  file.tracker.set_dirty(true);
-  file.tracker.set_active(false);
-  file.should_be_absent = false;
-  file.tracker_only = true;
-
-  disabled_app_root.tracker.set_dirty(false);
-  disabled_app_root.tracker.set_needs_folder_listing(false);
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-  VerifyReloadConsistency();
+  for (size_t i = 0; i < arraysize(index_types); ++i) {
+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    TrackedFile sync_root(CreateTrackedSyncRoot());
+    TrackedFile disabled_app_root(
+        CreateTrackedAppRoot(sync_root, "disabled_app"));
+    disabled_app_root.tracker.set_dirty(true);
+    disabled_app_root.tracker.set_needs_folder_listing(true);
+
+    TrackedFile known_file(CreateTrackedFile(disabled_app_root, "known_file"));
+    TrackedFile file(CreateTrackedFile(disabled_app_root, "file"));
+    file.should_be_absent = true;
+
+    const TrackedFile* tracked_files[] = {
+      &sync_root, &disabled_app_root, &disabled_app_root, &known_file, &file,
+    };
+
+    SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+
+    FileIDList disabled_app_children;
+    disabled_app_children.push_back(file.metadata.file_id());
+    EXPECT_EQ(SYNC_STATUS_OK, PopulateFolder(
+        disabled_app_root.metadata.file_id(), disabled_app_children));
+    ResetTrackerID(&file.tracker);
+    file.tracker.clear_synced_details();
+    file.tracker.set_dirty(true);
+    file.tracker.set_active(false);
+    file.should_be_absent = false;
+    file.tracker_only = true;
+
+    disabled_app_root.tracker.set_dirty(false);
+    disabled_app_root.tracker.set_needs_folder_listing(false);
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+    VerifyReloadConsistency();
+
+    TearDownEnv();
+  }
 }
 
 // TODO(tzik): Fix expectation and re-enable this test.
 TEST_F(MetadataDatabaseTest, DISABLED_UpdateTrackerTest) {
-  TrackedFile sync_root(CreateTrackedSyncRoot());
-  TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_root"));
-  TrackedFile file(CreateTrackedFile(app_root, "file"));
-  file.tracker.set_dirty(true);
-  file.metadata.mutable_details()->set_title("renamed file");
-
-  TrackedFile inactive_file(CreateTrackedFile(app_root, "inactive_file"));
-  inactive_file.tracker.set_active(false);
-  inactive_file.tracker.set_dirty(true);
-  inactive_file.metadata.mutable_details()->set_title("renamed inactive file");
-  inactive_file.metadata.mutable_details()->set_md5("modified_md5");
-
-  TrackedFile new_conflict(CreateTrackedFile(app_root, "new conflict file"));
-  new_conflict.tracker.set_dirty(true);
-  new_conflict.metadata.mutable_details()->set_title("renamed file");
-
-  const TrackedFile* tracked_files[] = {
-    &sync_root, &app_root, &file, &inactive_file, &new_conflict
-  };
-
-  SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-  VerifyReloadConsistency();
-
-  *file.tracker.mutable_synced_details() = file.metadata.details();
-  file.tracker.set_dirty(false);
-  EXPECT_EQ(SYNC_STATUS_OK, UpdateTracker(file.tracker));
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-  VerifyReloadConsistency();
-
-  *inactive_file.tracker.mutable_synced_details() =
-       inactive_file.metadata.details();
-  inactive_file.tracker.set_dirty(false);
-  inactive_file.tracker.set_active(true);
-  EXPECT_EQ(SYNC_STATUS_OK, UpdateTracker(inactive_file.tracker));
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-  VerifyReloadConsistency();
-
-  *new_conflict.tracker.mutable_synced_details() =
-       new_conflict.metadata.details();
-  new_conflict.tracker.set_dirty(false);
-  new_conflict.tracker.set_active(true);
-  file.tracker.set_dirty(true);
-  file.tracker.set_active(false);
-  EXPECT_EQ(SYNC_STATUS_OK, UpdateTracker(new_conflict.tracker));
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-  VerifyReloadConsistency();
+  for (size_t i = 0; i < arraysize(index_types); ++i) {
+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    TrackedFile sync_root(CreateTrackedSyncRoot());
+    TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_root"));
+    TrackedFile file(CreateTrackedFile(app_root, "file"));
+    file.tracker.set_dirty(true);
+    file.metadata.mutable_details()->set_title("renamed file");
+
+    TrackedFile inactive_file(CreateTrackedFile(app_root, "inactive_file"));
+    inactive_file.tracker.set_active(false);
+    inactive_file.tracker.set_dirty(true);
+    inactive_file.metadata.mutable_details()->set_title(
+        "renamed inactive file");
+    inactive_file.metadata.mutable_details()->set_md5("modified_md5");
+
+    TrackedFile new_conflict(CreateTrackedFile(app_root, "new conflict file"));
+    new_conflict.tracker.set_dirty(true);
+    new_conflict.metadata.mutable_details()->set_title("renamed file");
+
+    const TrackedFile* tracked_files[] = {
+      &sync_root, &app_root, &file, &inactive_file, &new_conflict
+    };
+
+    SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+    VerifyReloadConsistency();
+
+    *file.tracker.mutable_synced_details() = file.metadata.details();
+    file.tracker.set_dirty(false);
+    EXPECT_EQ(SYNC_STATUS_OK, UpdateTracker(file.tracker));
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+    VerifyReloadConsistency();
+
+    *inactive_file.tracker.mutable_synced_details() =
+        inactive_file.metadata.details();
+    inactive_file.tracker.set_dirty(false);
+    inactive_file.tracker.set_active(true);
+    EXPECT_EQ(SYNC_STATUS_OK, UpdateTracker(inactive_file.tracker));
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+    VerifyReloadConsistency();
+
+    *new_conflict.tracker.mutable_synced_details() =
+        new_conflict.metadata.details();
+    new_conflict.tracker.set_dirty(false);
+    new_conflict.tracker.set_active(true);
+    file.tracker.set_dirty(true);
+    file.tracker.set_active(false);
+    EXPECT_EQ(SYNC_STATUS_OK, UpdateTracker(new_conflict.tracker));
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+    VerifyReloadConsistency();
+
+    TearDownEnv();
+  }
 }
 
 TEST_F(MetadataDatabaseTest, PopulateInitialDataTest) {
-  TrackedFile sync_root(CreateTrackedSyncRoot());
-  TrackedFile app_root(CreateTrackedFolder(sync_root, "app_root"));
-  app_root.tracker.set_active(false);
-
-  const TrackedFile* tracked_files[] = {
-    &sync_root, &app_root
-  };
-
-  scoped_ptr<google_apis::FileResource> sync_root_folder(
-      CreateFileResourceFromMetadata(sync_root.metadata));
-  scoped_ptr<google_apis::FileResource> app_root_folder(
-      CreateFileResourceFromMetadata(app_root.metadata));
-
-  ScopedVector<google_apis::FileResource> app_root_folders;
-  app_root_folders.push_back(app_root_folder.release());
-
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-  EXPECT_EQ(SYNC_STATUS_OK, PopulateInitialData(
-      current_change_id(),
-      *sync_root_folder,
-      app_root_folders));
-
-  ResetTrackerID(&sync_root.tracker);
-  ResetTrackerID(&app_root.tracker);
-  app_root.tracker.set_parent_tracker_id(sync_root.tracker.tracker_id());
-
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-  VerifyReloadConsistency();
+  for (size_t i = 0; i < arraysize(index_types); ++i) {
+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    TrackedFile sync_root(CreateTrackedSyncRoot());
+    TrackedFile app_root(CreateTrackedFolder(sync_root, "app_root"));
+    app_root.tracker.set_active(false);
+
+    const TrackedFile* tracked_files[] = {
+      &sync_root, &app_root
+    };
+
+    scoped_ptr<google_apis::FileResource> sync_root_folder(
+        CreateFileResourceFromMetadata(sync_root.metadata));
+    scoped_ptr<google_apis::FileResource> app_root_folder(
+        CreateFileResourceFromMetadata(app_root.metadata));
+
+    ScopedVector<google_apis::FileResource> app_root_folders;
+    app_root_folders.push_back(app_root_folder.release());
+
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+    EXPECT_EQ(SYNC_STATUS_OK, PopulateInitialData(
+        current_change_id(),
+        *sync_root_folder,
+        app_root_folders));
+
+    ResetTrackerID(&sync_root.tracker);
+    ResetTrackerID(&app_root.tracker);
+    app_root.tracker.set_parent_tracker_id(sync_root.tracker.tracker_id());
+
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+    VerifyReloadConsistency();
+
+    TearDownEnv();
+  }
 }
 
 TEST_F(MetadataDatabaseTest, DumpFiles) {
-  TrackedFile sync_root(CreateTrackedSyncRoot());
-  TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_id"));
-  app_root.tracker.set_app_id(app_root.metadata.details().title());
-
-  TrackedFile folder_0(CreateTrackedFolder(app_root, "folder_0"));
-  TrackedFile file_0(CreateTrackedFile(folder_0, "file_0"));
-
-  const TrackedFile* tracked_files[] = {
-    &sync_root, &app_root, &folder_0, &file_0
-  };
-
-  SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
-  EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
-  VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
-
-  scoped_ptr<base::ListValue> files =
-      metadata_database()->DumpFiles(app_root.tracker.app_id());
-  ASSERT_EQ(2u, files->GetSize());
-
-  base::DictionaryValue* file = NULL;
-  std::string str;
-
-  ASSERT_TRUE(files->GetDictionary(0, &file));
-  EXPECT_TRUE(file->GetString("title", &str) && str == "folder_0");
-  EXPECT_TRUE(file->GetString("type", &str) && str == "folder");
-  EXPECT_TRUE(file->HasKey("details"));
-
-  ASSERT_TRUE(files->GetDictionary(1, &file));
-  EXPECT_TRUE(file->GetString("title", &str) && str == "file_0");
-  EXPECT_TRUE(file->GetString("type", &str) && str == "file");
-  EXPECT_TRUE(file->HasKey("details"));
+  for (size_t i = 0; i < arraysize(index_types); ++i) {
+    SetUpEnv();
+    SCOPED_TRACE(index_types[i].scope);
+
+    TrackedFile sync_root(CreateTrackedSyncRoot());
+    TrackedFile app_root(CreateTrackedAppRoot(sync_root, "app_id"));
+    app_root.tracker.set_app_id(app_root.metadata.details().title());
+
+    TrackedFile folder_0(CreateTrackedFolder(app_root, "folder_0"));
+    TrackedFile file_0(CreateTrackedFile(folder_0, "file_0"));
+
+    const TrackedFile* tracked_files[] = {
+      &sync_root, &app_root, &folder_0, &file_0
+    };
+
+    SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
+    EXPECT_EQ(SYNC_STATUS_OK,
+              InitializeMetadataDatabase(index_types[i].enable_on_disk));
+    VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
+
+    scoped_ptr<base::ListValue> files =
+        metadata_database()->DumpFiles(app_root.tracker.app_id());
+    ASSERT_EQ(2u, files->GetSize());
+
+    base::DictionaryValue* file = NULL;
+    std::string str;
+
+    ASSERT_TRUE(files->GetDictionary(0, &file));
+    EXPECT_TRUE(file->GetString("title", &str) && str == "folder_0");
+    EXPECT_TRUE(file->GetString("type", &str) && str == "folder");
+    EXPECT_TRUE(file->HasKey("details"));
+
+    ASSERT_TRUE(files->GetDictionary(1, &file));
+    EXPECT_TRUE(file->GetString("title", &str) && str == "file_0");
+    EXPECT_TRUE(file->GetString("type", &str) && str == "file");
+    EXPECT_TRUE(file->HasKey("details"));
+
+    TearDownEnv();
+  }
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system