[SyncFS] Make on-disk version default for metadata database index

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"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index_interface.h"
+#include "chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.h"
 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 #define FPL(a) FILE_PATH_LITERAL(a)
 
@@ skipping 426 matching lines @@
     PutFileMetadataToDB(file, db);
     return db->Commit();
   }
 
   leveldb::Status PutTrackerToDB(LevelDBWrapper* db,
                                  const FileTracker& tracker) {
     PutFileTrackerToDB(tracker, db);
     return db->Commit();
   }
 
+  void VerifyReloadConsistencyForOnMemory(MetadataDatabaseIndex* index1,
+                                          MetadataDatabaseIndex* index2) {
+    ExpectEquivalentServiceMetadata(index1, index2);
+    {
+      SCOPED_TRACE("Expect equivalent metadata_by_id_ contents.");
+      ExpectEquivalent(index1->metadata_by_id_, index2->metadata_by_id_);
+    }
+    {
+      SCOPED_TRACE("Expect equivalent tracker_by_id_ contents.");
+      ExpectEquivalent(index1->tracker_by_id_, index2->tracker_by_id_);
+    }
+    {
+      SCOPED_TRACE("Expect equivalent trackers_by_file_id_ contents.");
+      ExpectEquivalent(index1->trackers_by_file_id_,
+                       index2->trackers_by_file_id_);
+    }
+    {
+      SCOPED_TRACE("Expect equivalent app_root_by_app_id_ contents.");
+      ExpectEquivalent(index1->app_root_by_app_id_,
+                       index2->app_root_by_app_id_);
+    }
+    {
+      SCOPED_TRACE("Expect equivalent trackers_by_parent_and_title_ contents.");
+      ExpectEquivalent(index1->trackers_by_parent_and_title_,
+                       index2->trackers_by_parent_and_title_);
+    }
+    {
+      SCOPED_TRACE("Expect equivalent dirty_trackers_ contents.");
+      ExpectEquivalent(index1->dirty_trackers_, index2->dirty_trackers_);
+    }
+  }
+
+  void VerifyReloadConsistencyForOnDisk(
+      MetadataDatabaseIndexOnDisk* index1,
+      MetadataDatabaseIndexOnDisk* index2) {
+    ExpectEquivalentServiceMetadata(index1, index2);
+    scoped_ptr<LevelDBWrapper::Iterator> itr1 =
+        index1->GetDBForTesting()->NewIterator();
+    scoped_ptr<LevelDBWrapper::Iterator> itr2 =
+        index2->GetDBForTesting()->NewIterator();
+    for (itr1->SeekToFirst(), itr2->SeekToFirst();
+         itr1->Valid() && itr2->Valid();
+         itr1->Next(), itr2->Next()) {
+      EXPECT_EQ(itr1->key().ToString(), itr2->key().ToString());
+      EXPECT_EQ(itr1->value().ToString(), itr2->value().ToString());
+    }
+    EXPECT_TRUE(!itr1->Valid());
+    EXPECT_TRUE(!itr2->Valid());
+  }
+
   void VerifyReloadConsistency() {
     scoped_ptr<MetadataDatabase> metadata_database_2;
     ASSERT_EQ(SYNC_STATUS_OK,
               MetadataDatabase::CreateForTesting(
                   metadata_database_->db_.Pass(),
+                  metadata_database_->enable_on_disk_index_,
                   &metadata_database_2));
     metadata_database_->db_ = metadata_database_2->db_.Pass();
 
-    const MetadataDatabaseIndex* on_memory =
-        static_cast<MetadataDatabaseIndex*>(metadata_database_->index_.get());
-    const MetadataDatabaseIndex* reloaded =
-        static_cast<MetadataDatabaseIndex*>(metadata_database_2->index_.get());
-
-    {
-      SCOPED_TRACE("Expect equivalent service_metadata");
-      ExpectEquivalentServiceMetadata(metadata_database_->index_.get(),
-                                      metadata_database_2->index_.get());
-    }
-
-    {
-      SCOPED_TRACE("Expect equivalent metadata_by_id_ contents.");
-      ExpectEquivalent(on_memory->metadata_by_id_,
-                       reloaded->metadata_by_id_);
-    }
-
-    {
-      SCOPED_TRACE("Expect equivalent tracker_by_id_ contents.");
-      ExpectEquivalent(on_memory->tracker_by_id_,
-                       reloaded->tracker_by_id_);
-    }
-
-    {
-      SCOPED_TRACE("Expect equivalent trackers_by_file_id_ contents.");
-      ExpectEquivalent(on_memory->trackers_by_file_id_,
-                       reloaded->trackers_by_file_id_);
-    }
-
-    {
-      SCOPED_TRACE("Expect equivalent app_root_by_app_id_ contents.");
-      ExpectEquivalent(on_memory->app_root_by_app_id_,
-                       reloaded->app_root_by_app_id_);
-    }
-
-    {
-      SCOPED_TRACE("Expect equivalent trackers_by_parent_and_title_ contents.");
-      ExpectEquivalent(on_memory->trackers_by_parent_and_title_,
-                       reloaded->trackers_by_parent_and_title_);
-    }
-
-    {
-      SCOPED_TRACE("Expect equivalent dirty_trackers_ contents.");
-      ExpectEquivalent(on_memory->dirty_trackers_,
-                       reloaded->dirty_trackers_);
+    MetadataDatabaseIndexInterface* index1 = metadata_database_->index_.get();
+    MetadataDatabaseIndexInterface* index2 = metadata_database_2->index_.get();
+    if (metadata_database_->enable_on_disk_index_) {
+      VerifyReloadConsistencyForOnDisk(
+          static_cast<MetadataDatabaseIndexOnDisk*>(index1),
+          static_cast<MetadataDatabaseIndexOnDisk*>(index2));
+    } else {
+      VerifyReloadConsistencyForOnMemory(
+          static_cast<MetadataDatabaseIndex*>(index1),
+          static_cast<MetadataDatabaseIndex*>(index2));
     }
   }
 
   void VerifyFile(const FileMetadata& file) {
     FileMetadata file_in_metadata_database;
     ASSERT_TRUE(metadata_database()->FindFileByFileID(
         file.file_id(), &file_in_metadata_database));
 
     SCOPED_TRACE("Expect equivalent " + file.file_id());
     ExpectEquivalent(&file, &file_in_metadata_database);
@@ skipping 639 matching lines @@
   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"));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system