[SyncFS] Handle dirty tracker IDs in MetadataDatabaseIndexOnDisk

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 25 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 {
 
+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:
       return "folder";
   }
 
@@ skipping 1304 matching lines @@
   tracker_to_be_activated->set_dirty(false);
 
   index_->StoreFileTracker(tracker_to_be_activated.Pass(), batch.get());
 
   WriteToDatabase(batch.Pass(), callback);
   return ACTIVATION_PENDING;
 }
 
 void MetadataDatabase::LowerTrackerPriority(int64 tracker_id) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-  index_->DemoteDirtyTracker(tracker_id);
+  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
+  index_->DemoteDirtyTracker(tracker_id, batch.get());
+  WriteToDatabase(batch.Pass(), base::Bind(&EmptyStatusCallback));
 }
 
 void MetadataDatabase::PromoteLowerPriorityTrackersToNormal() {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-  index_->PromoteDemotedDirtyTrackers();
+  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
+  index_->PromoteDemotedDirtyTrackers(batch.get());
+  WriteToDatabase(batch.Pass(), base::Bind(&EmptyStatusCallback));
 }
 
 bool MetadataDatabase::GetNormalPriorityDirtyTracker(
     FileTracker* tracker_out) const {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   int64 dirty_tracker_id = index_->PickDirtyTracker();
   if (!dirty_tracker_id)
     return false;
 
@@ skipping 400 matching lines @@
                                        const SyncStatusCallback& callback) {
   DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
 
   if (!batch) {
     worker_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(callback, 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));
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpFiles(
@@ skipping 210 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