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

chrome/browser/sync_file_system/drive_backend/metadata_database.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 <algorithm>
 #include <stack>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/status.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 namespace sync_file_system {
 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) {}
 
 std::string FileKindToString(FileKind file_kind) {
   switch (file_kind) {
     case FILE_KIND_UNSUPPORTED:
       return "unsupported";
     case FILE_KIND_FILE:
       return "file";
     case FILE_KIND_FOLDER:
@@ skipping 195 matching lines @@
       // Drop all data in old database and refetch them from the remote service.
       NOTREACHED();
       return SYNC_DATABASE_ERROR_FAILED;
     case 3:
       DCHECK_EQ(3, kCurrentDatabaseVersion);
       // If MetadataDatabaseOnDisk is enabled, migration will be done in
       // MetadataDatabaseOnDisk::Create().
       // 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;
     default:
       return SYNC_DATABASE_ERROR_FAILED;
   }
 }
 
 bool HasInvalidTitle(const std::string& title) {
   return title.empty() ||
@@ skipping 267 matching lines @@
       base::Passed(make_scoped_ptr(new CreateParam(
           worker_task_runner,
           database_path,
           env_override))),
       callback));
 }
 
 // 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)
     *metadata_database_out = metadata_database.Pass();
   return status;
 }
 
 MetadataDatabase::~MetadataDatabase() {
   worker_task_runner_->DeleteSoon(FROM_HERE, db_.release());
 }
@@ skipping 830 matching lines @@
     tracker->set_dirty(false);
     index_->StoreFileTracker(tracker.Pass());
   }
 
   WriteToDatabase(callback);
 }
 
 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());
 }
 
 // static
 void MetadataDatabase::CreateOnWorkerTaskRunner(
     scoped_ptr<CreateParam> create_param,
     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();
   if (status == SYNC_DATABASE_ERROR_FAILED) {
     // Delete the previous instance to avoid creating a LevelDB instance for
     // the same path.
     metadata_database.reset();
 
     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();
   }
 
   if (status != SYNC_STATUS_OK)
     metadata_database.reset();
 
   if (metadata_database)
     metadata_database->DetachFromSequence();
   create_param->worker_task_runner->PostTask(
@@ skipping 14 matching lines @@
     if (status != SYNC_STATUS_OK)
       return status;
   }
 
   if (!created) {
     status = MigrateDatabaseIfNeeded(db_.get());
     if (status != SYNC_STATUS_OK)
       return status;
   }
 
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          kEnableMetadataDatabaseOnDisk)) {
+  if (enable_on_disk_index_) {
     index_ = MetadataDatabaseIndexOnDisk::Create(db_.get());
   } else {
     index_ = MetadataDatabaseIndex::Create(db_.get());
   }
   if (!index_) {
     // Delete all entries in |db_| to reset it.
     // TODO(peria): Make LevelDBWrapper::DestroyDB() to avoid a full scan.
     scoped_ptr<LevelDBWrapper::Iterator> itr = db_->NewIterator();
     for (itr->SeekToFirst(); itr->Valid();)
       itr->Delete();
@@ skipping 495 matching lines @@
       return false;
 
   if (!parents.empty())
     return false;
 
   return true;
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system