[SyncFS] Remove usage of file task runner under drive_backend/

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 173 matching lines @@
   *app_root_tracker->mutable_synced_details() = app_root_metadata.details();
   return app_root_tracker.Pass();
 }
 
 scoped_ptr<FileTracker> CloneFileTracker(const FileTracker* obj) {
   if (!obj)
     return scoped_ptr<FileTracker>();
   return scoped_ptr<FileTracker>(new FileTracker(*obj));
 }
 
-void WriteOnFileTaskRunner(
-    leveldb::DB* db,
-    scoped_ptr<leveldb::WriteBatch> batch,
-    scoped_refptr<base::SequencedTaskRunner> worker_task_runner,
-    const SyncStatusCallback& callback) {
-  DCHECK(db);
-  DCHECK(batch);
-  leveldb::Status status = db->Write(leveldb::WriteOptions(), batch.get());
-  worker_task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(callback, LevelDBStatusToSyncStatusCode(status)));
-}
-
 // Returns true if |db| has no content.
 bool IsDatabaseEmpty(leveldb::DB* db) {
   DCHECK(db);
   scoped_ptr<leveldb::Iterator> itr(db->NewIterator(leveldb::ReadOptions()));
   itr->SeekToFirst();
   return !itr->Valid();
 }
 
 SyncStatusCode OpenDatabase(const base::FilePath& path,
                             leveldb::Env* env_override,
@@ skipping 319 matching lines @@
 
   if (index->GetFileTrackerIDsByFileID(file_id).empty()) {
     index->RemoveFileMetadata(file_id, batch);
   }
 }
 
 }  // namespace
 
 struct MetadataDatabase::CreateParam {
   scoped_refptr<base::SequencedTaskRunner> worker_task_runner;
-  scoped_refptr<base::SequencedTaskRunner> file_task_runner;
   base::FilePath database_path;
   leveldb::Env* env_override;
 
   CreateParam(base::SequencedTaskRunner* worker_task_runner,
-              base::SequencedTaskRunner* file_task_runner,
               const base::FilePath& database_path,
               leveldb::Env* env_override)
       : worker_task_runner(worker_task_runner),
-        file_task_runner(file_task_runner),
         database_path(database_path),
         env_override(env_override) {
   }
 };
 
 // static
 void MetadataDatabase::Create(base::SequencedTaskRunner* worker_task_runner,
-                              base::SequencedTaskRunner* file_task_runner,
                               const base::FilePath& database_path,
                               leveldb::Env* env_override,
                               const CreateCallback& callback) {
-  file_task_runner->PostTask(FROM_HERE, base::Bind(
-      &MetadataDatabase::CreateOnFileTaskRunner,
+  worker_task_runner->PostTask(FROM_HERE, base::Bind(
+      &MetadataDatabase::CreateOnWorkerTaskRunner,
       base::Passed(make_scoped_ptr(new CreateParam(
           worker_task_runner,
-          file_task_runner,
           database_path,
           env_override))),
       callback));
 }
 
 // static
 SyncStatusCode MetadataDatabase::CreateForTesting(
     scoped_ptr<leveldb::DB> db,
     scoped_ptr<MetadataDatabase>* metadata_database_out) {
   scoped_ptr<MetadataDatabase> metadata_database(
       new MetadataDatabase(base::ThreadTaskRunnerHandle::Get(),
-                           base::ThreadTaskRunnerHandle::Get(),
                            base::FilePath(), NULL));
   metadata_database->db_ = db.Pass();
-  SyncStatusCode status =
-      metadata_database->InitializeOnFileTaskRunner();
+  SyncStatusCode status = metadata_database->Initialize();
   if (status == SYNC_STATUS_OK)
     *metadata_database_out = metadata_database.Pass();
   return status;
 }
 
 MetadataDatabase::~MetadataDatabase() {
-  file_task_runner_->DeleteSoon(FROM_HERE, db_.release());
+  worker_task_runner_->DeleteSoon(FROM_HERE, db_.release());
 }
 
 // static
 void MetadataDatabase::ClearDatabase(
     scoped_ptr<MetadataDatabase> metadata_database) {
   DCHECK(metadata_database);
-  scoped_refptr<base::SequencedTaskRunner> file_task_runner =
-      metadata_database->file_task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> worker_task_runner =
+      metadata_database->worker_task_runner_;
   base::FilePath database_path = metadata_database->database_path_;
   DCHECK(!database_path.empty());
   metadata_database.reset();
 
-  file_task_runner->PostTask(
+  worker_task_runner->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(base::DeleteFile),
                  database_path, true /* recursive */));
 }
 
 int64 MetadataDatabase::GetLargestFetchedChangeID() const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->GetLargestChangeID();
 }
 
@@ skipping 798 matching lines @@
 }
 
 void MetadataDatabase::GetRegisteredAppIDs(std::vector<std::string>* app_ids) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(app_ids);
   *app_ids = index_->GetRegisteredAppIDs();
 }
 
 MetadataDatabase::MetadataDatabase(
     base::SequencedTaskRunner* worker_task_runner,
-    base::SequencedTaskRunner* file_task_runner,
     const base::FilePath& database_path,
     leveldb::Env* env_override)
     : worker_task_runner_(worker_task_runner),
-      file_task_runner_(file_task_runner),
       database_path_(database_path),
       env_override_(env_override),
       largest_known_change_id_(0),
       weak_ptr_factory_(this) {
   DCHECK(worker_task_runner);
-  DCHECK(file_task_runner);
 }
 
 // static
-void MetadataDatabase::CreateOnFileTaskRunner(
+void MetadataDatabase::CreateOnWorkerTaskRunner(
     scoped_ptr<CreateParam> create_param,
     const CreateCallback& callback) {
+  DCHECK(create_param->worker_task_runner->RunsTasksOnCurrentThread());
+
   scoped_ptr<MetadataDatabase> metadata_database(
       new MetadataDatabase(create_param->worker_task_runner.get(),
-                           create_param->file_task_runner.get(),
                            create_param->database_path,
                            create_param->env_override));
-  SyncStatusCode status =
-      metadata_database->InitializeOnFileTaskRunner();
+  SyncStatusCode status = metadata_database->Initialize();
   if (status != SYNC_STATUS_OK)
     metadata_database.reset();
 
   metadata_database->DetachFromSequence();
   create_param->worker_task_runner->PostTask(
       FROM_HERE,
       base::Bind(
           callback, status, base::Passed(&metadata_database)));
 }
 
-SyncStatusCode MetadataDatabase::InitializeOnFileTaskRunner() {
+SyncStatusCode MetadataDatabase::Initialize() {
   base::ThreadRestrictions::AssertIOAllowed();
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   SyncStatusCode status = SYNC_STATUS_UNKNOWN;
   bool created = false;
   // Open database unless |db_| is overridden for testing.
   if (!db_) {
     status = OpenDatabase(database_path_, env_override_, &db_, &created);
     if (status != SYNC_STATUS_OK)
       return status;
   }
 
@@ skipping 258 matching lines @@
     if (option != UPDATE_TRACKER_FOR_SYNCED_FILE)
       MarkTrackerSetDirty(trackers, index_.get(), batch);
   }
 }
 
 void MetadataDatabase::WriteToDatabase(scoped_ptr<leveldb::WriteBatch> batch,
                                        const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   if (!batch) {
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_STATUS_OK));
+    callback.Run(SYNC_STATUS_OK);
     return;
   }
 
-  // TODO(peria): Write to DB on disk synchronously.
-  file_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&WriteOnFileTaskRunner,
-                 base::Unretained(db_.get()),
-                 base::Passed(&batch),
-                 worker_task_runner_,
-                 callback));
+  leveldb::Status status = db_->Write(leveldb::WriteOptions(), batch.get());
+  callback.Run(LevelDBStatusToSyncStatusCode(status));
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpFiles(
     const std::string& app_id) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   scoped_ptr<base::ListValue> files(new base::ListValue);
 
   FileTracker app_root_tracker;
   if (!FindAppRootTracker(app_id, &app_root_tracker))
@@ skipping 201 matching lines @@
   index_->StoreFileMetadata(app_root_metadata.Pass(), batch);
   index_->StoreFileTracker(app_root_tracker.Pass(), batch);
 }
 
 void MetadataDatabase::DetachFromSequence() {
   worker_sequence_checker_.DetachFromSequence();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system