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

BUG=347425
TEST=unit_tests --gtest_filter="MetadataDatabase*"

Review URL: https://codereview.chromium.org/542233003

Cr-Commit-Position: refs/heads/master@{#293714}

chrome/browser/sync_file_system/drive_backend/metadata_database.cc

@@ -45,8 +45,8 @@ namespace drive_backend {
 
 namespace {
 
-// Command line flag to enable on-disk indexing.
-const char kEnableMetadataDatabaseOnDisk[] = "enable-syncfs-on-disk-indexing";
+// Command line flag to disable on-disk indexing.
+const char kDisableMetadataDatabaseOnDisk[] = "disable-syncfs-on-disk-indexing";
 
 void EmptyStatusCallback(SyncStatusCode status) {}
 
@@ -262,8 +262,8 @@ SyncStatusCode MigrateDatabaseIfNeeded(LevelDBWrapper* db) {
       // TODO(peria): Move the migration code (from v3 to v4) here.
       return SYNC_STATUS_OK;
     case 4:
-      if (!CommandLine::ForCurrentProcess()->HasSwitch(
-              kEnableMetadataDatabaseOnDisk)) {
+      if (CommandLine::ForCurrentProcess()->HasSwitch(
+              kDisableMetadataDatabaseOnDisk)) {
         MigrateDatabaseFromV4ToV3(db->GetLevelDB());
       }
       return SYNC_STATUS_OK;
@@ -551,10 +551,13 @@ void MetadataDatabase::Create(
 // static
 SyncStatusCode MetadataDatabase::CreateForTesting(
     scoped_ptr<LevelDBWrapper> db,
+    bool enable_on_disk_index,
     scoped_ptr<MetadataDatabase>* metadata_database_out) {
   scoped_ptr<MetadataDatabase> metadata_database(
       new MetadataDatabase(base::ThreadTaskRunnerHandle::Get(),
-                           base::FilePath(), NULL));
+                           base::FilePath(),
+                           enable_on_disk_index,
+                           NULL));
   metadata_database->db_ = db.Pass();
   SyncStatusCode status = metadata_database->Initialize();
   if (status == SYNC_STATUS_OK)
@@ -1405,10 +1408,12 @@ void MetadataDatabase::SweepDirtyTrackers(
 MetadataDatabase::MetadataDatabase(
     const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
     const base::FilePath& database_path,
+    bool enable_on_disk_index,
     leveldb::Env* env_override)
     : worker_task_runner_(worker_task_runner),
       database_path_(database_path),
       env_override_(env_override),
+      enable_on_disk_index_(enable_on_disk_index),
       largest_known_change_id_(0),
       weak_ptr_factory_(this) {
   DCHECK(worker_task_runner.get());
@@ -1420,9 +1425,12 @@ void MetadataDatabase::CreateOnWorkerTaskRunner(
     const CreateCallback& callback) {
   DCHECK(create_param->worker_task_runner->RunsTasksOnCurrentThread());
 
+  bool enable_on_disk_index = !CommandLine::ForCurrentProcess()->HasSwitch(
+      kDisableMetadataDatabaseOnDisk);
   scoped_ptr<MetadataDatabase> metadata_database(
       new MetadataDatabase(create_param->worker_task_runner,
                            create_param->database_path,
+                           enable_on_disk_index,
                            create_param->env_override));
 
   SyncStatusCode status = metadata_database->Initialize();
@@ -1434,6 +1442,7 @@ void MetadataDatabase::CreateOnWorkerTaskRunner(
     metadata_database.reset(
         new MetadataDatabase(create_param->worker_task_runner,
                              create_param->database_path,
+                             enable_on_disk_index,
                              create_param->env_override));
     status = metadata_database->Initialize();
   }
@@ -1468,8 +1477,7 @@ SyncStatusCode MetadataDatabase::Initialize() {
       return status;
   }
 
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          kEnableMetadataDatabaseOnDisk)) {
+  if (enable_on_disk_index_) {
     index_ = MetadataDatabaseIndexOnDisk::Create(db_.get());
   } else {
     index_ = MetadataDatabaseIndex::Create(db_.get());

chrome/browser/sync_file_system/drive_backend/metadata_database.h

@@ -139,6 +139,7 @@ class MetadataDatabase {
       const CreateCallback& callback);
   static SyncStatusCode CreateForTesting(
       scoped_ptr<LevelDBWrapper> db,
+      bool enable_on_disk_index,
       scoped_ptr<MetadataDatabase>* metadata_database_out);
 
   ~MetadataDatabase();
@@ -358,6 +359,7 @@ class MetadataDatabase {
   MetadataDatabase(
       const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
       const base::FilePath& database_path,
+      bool enable_on_disk_index,
       leveldb::Env* env_override);
   static void CreateOnWorkerTaskRunner(
       scoped_ptr<CreateParam> create_param,
@@ -418,6 +420,8 @@ class MetadataDatabase {
   leveldb::Env* env_override_;
   scoped_ptr<LevelDBWrapper> db_;
 
+  bool enable_on_disk_index_;
+
   int64 largest_known_change_id_;
 
   scoped_ptr<MetadataDatabaseIndexInterface> index_;

chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc

@@ -16,6 +16,7 @@
 #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"
@@ -462,59 +463,75 @@ class MetadataDatabaseTest : public testing::Test {
     return db->Commit();
   }
 
-  void VerifyReloadConsistency() {
-    scoped_ptr<MetadataDatabase> metadata_database_2;
-    ASSERT_EQ(SYNC_STATUS_OK,
-              MetadataDatabase::CreateForTesting(
-                  metadata_database_->db_.Pass(),
-                  &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());
-    }
-
+  void VerifyReloadConsistencyForOnMemory(MetadataDatabaseIndex* index1,
+                                          MetadataDatabaseIndex* index2) {
+    ExpectEquivalentServiceMetadata(index1, index2);
     {
       SCOPED_TRACE("Expect equivalent metadata_by_id_ contents.");
-      ExpectEquivalent(on_memory->metadata_by_id_,
-                       reloaded->metadata_by_id_);
+      ExpectEquivalent(index1->metadata_by_id_, index2->metadata_by_id_);
     }
-
     {
       SCOPED_TRACE("Expect equivalent tracker_by_id_ contents.");
-      ExpectEquivalent(on_memory->tracker_by_id_,
-                       reloaded->tracker_by_id_);
+      ExpectEquivalent(index1->tracker_by_id_, index2->tracker_by_id_);
     }
-
     {
       SCOPED_TRACE("Expect equivalent trackers_by_file_id_ contents.");
-      ExpectEquivalent(on_memory->trackers_by_file_id_,
-                       reloaded->trackers_by_file_id_);
+      ExpectEquivalent(index1->trackers_by_file_id_,
+                       index2->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_);
+      ExpectEquivalent(index1->app_root_by_app_id_,
+                       index2->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_);
+      ExpectEquivalent(index1->trackers_by_parent_and_title_,
+                       index2->trackers_by_parent_and_title_);
     }
-
     {
       SCOPED_TRACE("Expect equivalent dirty_trackers_ contents.");
-      ExpectEquivalent(on_memory->dirty_trackers_,
-                       reloaded->dirty_trackers_);
+      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();
+
+    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));
     }
   }
 

chrome/browser/sync_file_system/drive_backend/register_app_task_unittest.cc

@@ -125,7 +125,7 @@ class RegisterAppTaskTest : public testing::Test {
     scoped_ptr<MetadataDatabase> metadata_db;
     ASSERT_EQ(SYNC_STATUS_OK,
               MetadataDatabase::CreateForTesting(
-                  db.Pass(), &metadata_db));
+                  db.Pass(), true /* enable_on_disk_index */, &metadata_db));
     context_->SetMetadataDatabase(metadata_db.Pass());
   }