[SyncFS] Drop TaskRunner in MetadataDatabase

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 502 matching lines @@
     MarkTrackersDirtyByPath(parent_tracker_id, title, index);
 
   if (index->GetFileTrackerIDsByFileID(file_id).empty()) {
     index->RemoveFileMetadata(file_id);
   }
 }
 
 }  // namespace
 
 struct MetadataDatabase::CreateParam {
-  scoped_refptr<base::SequencedTaskRunner> worker_task_runner;
   base::FilePath database_path;
   leveldb::Env* env_override;
 
-  CreateParam(
-      const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
-      const base::FilePath& database_path,
-      leveldb::Env* env_override)
-      : worker_task_runner(worker_task_runner),
-        database_path(database_path),
+  CreateParam(const base::FilePath& database_path,
+              leveldb::Env* env_override)
+      : database_path(database_path),
         env_override(env_override) {}
 };
 
 // static
 void MetadataDatabase::Create(
-    const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
     const base::FilePath& database_path,
     leveldb::Env* env_override,
     const CreateCallback& callback) {
-  worker_task_runner->PostTask(FROM_HERE, base::Bind(
-      &MetadataDatabase::CreateOnWorkerTaskRunner,
-      base::Passed(make_scoped_ptr(new CreateParam(
-          worker_task_runner,
-          database_path,
-          env_override))),
-      callback));
+  CreateOnWorkerTaskRunner(
+      make_scoped_ptr(new CreateParam(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(),
+      new MetadataDatabase(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());
 }
 
 // static
 void MetadataDatabase::ClearDatabase(
     scoped_ptr<MetadataDatabase> metadata_database) {
   DCHECK(metadata_database);
-  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();
 
-  worker_task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(base::DeleteFile),
-                 database_path, true /* recursive */));
+  base::DeleteFile(database_path, true /* recursive */);
 }
 
 int64 MetadataDatabase::GetLargestFetchedChangeID() const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->GetLargestChangeID();
 }
 
 int64 MetadataDatabase::GetSyncRootTrackerID() const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->GetSyncRootTrackerID();
 }
 
 int64 MetadataDatabase::GetLargestKnownChangeID() const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK_LE(GetLargestFetchedChangeID(), largest_known_change_id_);
   return largest_known_change_id_;
 }
 
 void MetadataDatabase::UpdateLargestKnownChangeID(int64 change_id) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   if (largest_known_change_id_ < change_id)
     largest_known_change_id_ = change_id;
 }
 
 bool MetadataDatabase::HasSyncRoot() const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->GetSyncRootTrackerID() != kInvalidTrackerID;
 }
 
 void MetadataDatabase::PopulateInitialData(
     int64 largest_change_id,
     const google_apis::FileResource& sync_root_folder,
     const ScopedVector<google_apis::FileResource>& app_root_folders,
     const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   index_->SetLargestChangeID(largest_change_id);
   UpdateLargestKnownChangeID(largest_change_id);
 
   AttachSyncRoot(sync_root_folder);
   for (size_t i = 0; i < app_root_folders.size(); ++i)
     AttachInitialAppRoot(*app_root_folders[i]);
 
   WriteToDatabase(callback);
 }
 
 bool MetadataDatabase::IsAppEnabled(const std::string& app_id) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   if (tracker_id == kInvalidTrackerID)
     return false;
 
   FileTracker tracker;
   if (!index_->GetFileTracker(tracker_id, &tracker))
     return false;
   return tracker.tracker_kind() == TRACKER_KIND_APP_ROOT;
 }
 
 void MetadataDatabase::RegisterApp(const std::string& app_id,
                                    const std::string& folder_id,
                                    const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   if (index_->GetAppRootTracker(app_id)) {
     // The app-root is already registered.
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_STATUS_OK));
+    callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(folder_id);
   if (trackers.empty()) {
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
+    callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
     return;
   }
 
   if (trackers.has_active()) {
     // The folder is tracked by another tracker.
     util::Log(logging::LOG_WARNING, FROM_HERE,
               "Failed to register App for %s", app_id.c_str());
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_STATUS_HAS_CONFLICT));
+    callback.Run(SYNC_STATUS_HAS_CONFLICT);
     return;
   }
 
   int64 sync_root_tracker_id = index_->GetSyncRootTrackerID();
   if (!sync_root_tracker_id) {
     util::Log(logging::LOG_WARNING, FROM_HERE,
               "Sync-root needs to be set up before registering app-root");
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
+    callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
     return;
   }
 
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!FilterFileTrackersByParent(index_.get(), trackers,
                                   sync_root_tracker_id, tracker.get())) {
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
+    callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
     return;
   }
 
   tracker->set_app_id(app_id);
   tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
   tracker->set_active(true);
   tracker->set_needs_folder_listing(true);
   tracker->set_dirty(true);
 
   index_->StoreFileTracker(tracker.Pass());
   WriteToDatabase(callback);
 }
 
 void MetadataDatabase::DisableApp(const std::string& app_id,
                                   const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
     callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
     return;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   DCHECK_EQ(TRACKER_KIND_APP_ROOT, tracker->tracker_kind());
   DCHECK(tracker->active());
 
   // Keep the app-root tracker active (but change the tracker_kind) so that
   // other conflicting trackers won't become active.
   tracker->set_tracker_kind(TRACKER_KIND_DISABLED_APP_ROOT);
 
   index_->StoreFileTracker(tracker.Pass());
   WriteToDatabase(callback);
 }
 
 void MetadataDatabase::EnableApp(const std::string& app_id,
                                  const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
     callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
     return;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_APP_ROOT) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   DCHECK_EQ(TRACKER_KIND_DISABLED_APP_ROOT, tracker->tracker_kind());
   DCHECK(tracker->active());
 
   tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
   index_->StoreFileTracker(tracker.Pass());
 
   MarkTrackersDirtyRecursively(tracker_id, index_.get());
   WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UnregisterApp(const std::string& app_id,
                                      const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get()) ||
       tracker->tracker_kind() == TRACKER_KIND_REGULAR) {
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_STATUS_OK));
+    callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   RemoveAllDescendantTrackers(tracker_id, index_.get());
 
   tracker->clear_app_id();
   tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   tracker->set_active(false);
   tracker->set_dirty(true);
 
   index_->StoreFileTracker(tracker.Pass());
   WriteToDatabase(callback);
 }
 
 bool MetadataDatabase::FindAppRootTracker(const std::string& app_id,
                                           FileTracker* tracker_out) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   int64 app_root_tracker_id = index_->GetAppRootTracker(app_id);
   if (!app_root_tracker_id)
     return false;
 
   if (tracker_out &&
       !index_->GetFileTracker(app_root_tracker_id, tracker_out)) {
     NOTREACHED();
     return false;
   }
 
   return true;
 }
 
 bool MetadataDatabase::FindFileByFileID(const std::string& file_id,
                                         FileMetadata* metadata_out) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->GetFileMetadata(file_id, metadata_out);
 }
 
 bool MetadataDatabase::FindTrackersByFileID(const std::string& file_id,
                                             TrackerIDSet* trackers_out) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   if (trackers.empty())
     return false;
 
   if (trackers_out)
     std::swap(trackers, *trackers_out);
   return true;
 }
 
 bool MetadataDatabase::FindTrackersByParentAndTitle(
     int64 parent_tracker_id,
     const std::string& title,
     TrackerIDSet* trackers_out) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   TrackerIDSet trackers =
       index_->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title);
   if (trackers.empty())
     return false;
 
   if (trackers_out)
     std::swap(trackers, *trackers_out);
   return true;
 }
 
 bool MetadataDatabase::FindTrackerByTrackerID(int64 tracker_id,
                                               FileTracker* tracker_out) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->GetFileTracker(tracker_id, tracker_out);
 }
 
 bool MetadataDatabase::BuildPathForTracker(int64 tracker_id,
                                            base::FilePath* path) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   FileTracker current;
   if (!FindTrackerByTrackerID(tracker_id, &current) || !current.active())
     return false;
 
   std::vector<base::FilePath> components;
   while (!IsAppRoot(current)) {
     std::string title = GetTrackerTitle(current);
     if (title.empty())
       return false;
     components.push_back(base::FilePath::FromUTF8Unsafe(title));
     if (!FindTrackerByTrackerID(current.parent_tracker_id(), &current) ||
         !current.active())
       return false;
   }
 
   if (path)
     *path = ReverseConcatPathComponents(components);
 
   return true;
 }
 
 base::FilePath MetadataDatabase::BuildDisplayPathForTracker(
     const FileTracker& tracker) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   base::FilePath path;
   if (tracker.active()) {
     BuildPathForTracker(tracker.tracker_id(), &path);
     return path;
   }
   BuildPathForTracker(tracker.parent_tracker_id(), &path);
   if (tracker.has_synced_details()) {
     path = path.Append(
         base::FilePath::FromUTF8Unsafe(tracker.synced_details().title()));
   } else {
     path = path.Append(FILE_PATH_LITERAL("<unknown>"));
   }
   return path;
 }
 
 bool MetadataDatabase::FindNearestActiveAncestor(
     const std::string& app_id,
     const base::FilePath& full_path,
     FileTracker* tracker_out,
     base::FilePath* path_out) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(tracker_out);
   DCHECK(path_out);
 
   if (full_path.IsAbsolute() ||
       !FindAppRootTracker(app_id, tracker_out) ||
       tracker_out->tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT) {
     return false;
   }
 
   std::vector<base::FilePath::StringType> components;
@@ skipping 23 matching lines @@
     *path_out = path_out->Append(components[i]);
   }
 
   return true;
 }
 
 void MetadataDatabase::UpdateByChangeList(
     int64 largest_change_id,
     ScopedVector<google_apis::ChangeResource> changes,
     const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK_LE(index_->GetLargestChangeID(), largest_change_id);
 
   for (size_t i = 0; i < changes.size(); ++i) {
     const google_apis::ChangeResource& change = *changes[i];
     if (HasNewerFileMetadata(change.file_id(), change.change_id()))
       continue;
 
     scoped_ptr<FileMetadata> metadata(
         CreateFileMetadataFromChangeResource(change));
     UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
 
   UpdateLargestKnownChangeID(largest_change_id);
   index_->SetLargestChangeID(largest_change_id);
   WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UpdateByFileResource(
     const google_apis::FileResource& resource,
     const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   scoped_ptr<FileMetadata> metadata(
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), resource));
   UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                        UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UpdateByFileResourceList(
     ScopedVector<google_apis::FileResource> resources,
     const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   for (size_t i = 0; i < resources.size(); ++i) {
     scoped_ptr<FileMetadata> metadata(
         CreateFileMetadataFromFileResource(
             GetLargestKnownChangeID(), *resources[i]));
     UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
   WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UpdateByDeletedRemoteFile(
     const std::string& file_id,
     const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   scoped_ptr<FileMetadata> metadata(
       CreateDeletedFileMetadata(GetLargestKnownChangeID(), file_id));
   UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                        UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UpdateByDeletedRemoteFileList(
     const FileIDList& file_ids,
     const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   for (FileIDList::const_iterator itr = file_ids.begin();
        itr != file_ids.end(); ++itr) {
     scoped_ptr<FileMetadata> metadata(
         CreateDeletedFileMetadata(GetLargestKnownChangeID(), *itr));
     UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
   WriteToDatabase(callback);
 }
 
 void MetadataDatabase::ReplaceActiveTrackerWithNewResource(
     int64 parent_tracker_id,
     const google_apis::FileResource& resource,
     const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   DCHECK(!index_->GetFileMetadata(resource.file_id(), NULL));
   DCHECK(index_->GetFileTracker(parent_tracker_id, NULL));
 
   UpdateByFileMetadata(
       FROM_HERE,
       CreateFileMetadataFromFileResource(GetLargestKnownChangeID(), resource),
       UPDATE_TRACKER_FOR_SYNCED_FILE);
 
   DCHECK(index_->GetFileMetadata(resource.file_id(), NULL));
   DCHECK(!index_->GetFileTrackerIDsByFileID(resource.file_id()).has_active());
 
   TrackerIDSet same_path_trackers =
       index_->GetFileTrackerIDsByParentAndTitle(
           parent_tracker_id, resource.title());
   FileTracker to_be_activated;
   if (!FilterFileTrackersByFileID(index_.get(), same_path_trackers,
                                   resource.file_id(), &to_be_activated)) {
     NOTREACHED();
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_STATUS_FAILED));
+    callback.Run(SYNC_STATUS_FAILED);
     return;
   }
 
   int64 tracker_id = to_be_activated.tracker_id();
   if (same_path_trackers.has_active()) {
     DeactivateFileTracker(same_path_trackers.active_tracker(),
                           MARK_ITSELF_DIRTY |
                           MARK_SAME_FILE_ID_TRACKERS_DIRTY,
                           index_.get());
   }
 
   ActivateFileTracker(tracker_id, MARK_NOTHING_DIRTY, index_.get());
   WriteToDatabase(callback);
 }
 
 void MetadataDatabase::PopulateFolderByChildList(
     const std::string& folder_id,
     const FileIDList& child_file_ids,
     const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(folder_id);
   if (!trackers.has_active()) {
     // It's OK that there is no folder to populate its children.
     // Inactive folders should ignore their contents updates.
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_STATUS_OK));
+    callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   scoped_ptr<FileTracker> folder_tracker(new FileTracker);
   if (!index_->GetFileTracker(trackers.active_tracker(),
                               folder_tracker.get())) {
     NOTREACHED();
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_STATUS_FAILED));
+    callback.Run(SYNC_STATUS_FAILED);
     return;
   }
 
   base::hash_set<std::string> children(child_file_ids.begin(),
                                        child_file_ids.end());
 
   std::vector<int64> known_children =
       index_->GetFileTrackerIDsByParent(folder_tracker->tracker_id());
   for (size_t i = 0; i < known_children.size(); ++i) {
     FileTracker tracker;
@@ skipping 11 matching lines @@
   if (folder_tracker->dirty() && !ShouldKeepDirty(*folder_tracker))
     folder_tracker->set_dirty(false);
   index_->StoreFileTracker(folder_tracker.Pass());
 
   WriteToDatabase(callback);
 }
 
 void MetadataDatabase::UpdateTracker(int64 tracker_id,
                                      const FileDetails& updated_details,
                                      const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   FileTracker tracker;
   if (!index_->GetFileTracker(tracker_id, &tracker)) {
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
+    callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
     return;
   }
 
   // Check if the tracker is to be deleted.
   if (updated_details.missing()) {
     FileMetadata metadata;
     if (!index_->GetFileMetadata(tracker.file_id(), &metadata) ||
         metadata.details().missing()) {
       // Both the tracker and metadata have the missing flag, now it's safe to
       // delete the |tracker|.
@@ skipping 78 matching lines @@
   if (should_promote)
     index_->PromoteDemotedDirtyTracker(tracker_id);
 
   WriteToDatabase(callback);
 }
 
 MetadataDatabase::ActivationStatus MetadataDatabase::TryActivateTracker(
     int64 parent_tracker_id,
     const std::string& file_id,
     const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   FileMetadata metadata;
   if (!index_->GetFileMetadata(file_id, &metadata)) {
     NOTREACHED();
-    worker_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(callback, SYNC_STATUS_FAILED));
+    callback.Run(SYNC_STATUS_FAILED);
     return ACTIVATION_PENDING;
   }
   std::string title = metadata.details().title();
   DCHECK(!HasInvalidTitle(title));
 
   TrackerIDSet same_file_id_trackers =
       index_->GetFileTrackerIDsByFileID(file_id);
   scoped_ptr<FileTracker> tracker_to_be_activated(new FileTracker);
   FilterFileTrackersByParentAndTitle(
       index_.get(), same_file_id_trackers, parent_tracker_id,
@@ skipping 38 matching lines @@
   }
   tracker_to_be_activated->set_dirty(false);
 
   index_->StoreFileTracker(tracker_to_be_activated.Pass());
 
   WriteToDatabase(callback);
   return ACTIVATION_PENDING;
 }
 
 void MetadataDatabase::DemoteTracker(int64 tracker_id) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   index_->DemoteDirtyTracker(tracker_id);
   WriteToDatabase(base::Bind(&EmptyStatusCallback));
 }
 
 bool MetadataDatabase::PromoteDemotedTrackers() {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   bool promoted = index_->PromoteDemotedDirtyTrackers();
   WriteToDatabase(base::Bind(&EmptyStatusCallback));
   return promoted;
 }
 
 void MetadataDatabase::PromoteDemotedTracker(int64 tracker_id) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   index_->PromoteDemotedDirtyTracker(tracker_id);
   WriteToDatabase(base::Bind(&EmptyStatusCallback));
 }
 
 bool MetadataDatabase::GetDirtyTracker(
     FileTracker* tracker_out) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   int64 dirty_tracker_id = index_->PickDirtyTracker();
   if (!dirty_tracker_id)
     return false;
 
   if (tracker_out) {
     if (!index_->GetFileTracker(dirty_tracker_id, tracker_out)) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool MetadataDatabase::HasDemotedDirtyTracker() const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->HasDemotedDirtyTracker();
 }
 
 bool MetadataDatabase::HasDirtyTracker() const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->PickDirtyTracker() != kInvalidTrackerID;
 }
 
 size_t MetadataDatabase::CountDirtyTracker() const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->CountDirtyTracker();
 }
 
 bool MetadataDatabase::GetMultiParentFileTrackers(std::string* file_id_out,
                                                   TrackerIDSet* trackers_out) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(file_id_out);
   DCHECK(trackers_out);
 
   std::string file_id = index_->PickMultiTrackerFileID();
   if (file_id.empty())
     return false;
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   if (trackers.size() <= 1) {
     NOTREACHED();
     return false;
   }
 
   *file_id_out = file_id;
   std::swap(*trackers_out, trackers);
   return true;
 }
 
 size_t MetadataDatabase::CountFileMetadata() const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->CountFileMetadata();
 }
 
 size_t MetadataDatabase::CountFileTracker() const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->CountFileTracker();
 }
 
 bool MetadataDatabase::GetConflictingTrackers(TrackerIDSet* trackers_out) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(trackers_out);
 
   ParentIDAndTitle parent_and_title = index_->PickMultiBackingFilePath();
   if (parent_and_title.parent_id == kInvalidTrackerID)
     return false;
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByParentAndTitle(
       parent_and_title.parent_id, parent_and_title.title);
   if (trackers.size() <= 1) {
     NOTREACHED();
     return false;
   }
 
   std::swap(*trackers_out, trackers);
   return true;
 }
 
 void MetadataDatabase::GetRegisteredAppIDs(std::vector<std::string>* app_ids) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(app_ids);
   *app_ids = index_->GetRegisteredAppIDs();
 }
 
 void MetadataDatabase::SweepDirtyTrackers(
     const std::vector<std::string>& file_ids,
     const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   std::set<int64> tracker_ids;
   for (size_t i = 0; i < file_ids.size(); ++i) {
     TrackerIDSet trackers_for_file_id =
         index_->GetFileTrackerIDsByFileID(file_ids[i]);
     for (TrackerIDSet::iterator itr = trackers_for_file_id.begin();
          itr != trackers_for_file_id.end(); ++itr)
       tracker_ids.insert(*itr);
   }
 
   for (std::set<int64>::iterator itr = tracker_ids.begin();
        itr != tracker_ids.end(); ++itr) {
     scoped_ptr<FileTracker> tracker(new FileTracker);
     if (!index_->GetFileTracker(*itr, tracker.get()) ||
         !CanClearDirty(*tracker))
       continue;
     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),
+    : 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) {

[peria, 2014/09/09 10:29:34]

I think we can merge this method into Create() and drop CreateParam.
WDYT?

[peria, 2014/09/09 10:32:13]

Please ignore the previous comment.
I found you did it in another CL.

-  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,
+      new MetadataDatabase(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,
+        new MetadataDatabase(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(
-      FROM_HERE,
-      base::Bind(
-          callback, status, base::Passed(&metadata_database)));
+  callback.Run(status, metadata_database.Pass());
 }
 
 SyncStatusCode MetadataDatabase::Initialize() {
-  base::ThreadRestrictions::AssertIOAllowed();
-  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;
   }
 
   if (!created) {
@@ skipping 23 matching lines @@
     return status;
 
   UpdateLargestKnownChangeID(index_->GetLargestChangeID());
 
   return status;
 }
 
 void MetadataDatabase::CreateTrackerForParentAndFileID(
     const FileTracker& parent_tracker,
     const std::string& file_id) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   CreateTrackerInternal(parent_tracker, file_id, NULL,
                         UPDATE_TRACKER_FOR_UNSYNCED_FILE);
 }
 
 void MetadataDatabase::CreateTrackerForParentAndFileMetadata(
     const FileTracker& parent_tracker,
     const FileMetadata& file_metadata,
     UpdateOption option) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(file_metadata.has_details());
   CreateTrackerInternal(parent_tracker,
                         file_metadata.file_id(),
                         &file_metadata.details(),
                         option);
 }
 
 void MetadataDatabase::CreateTrackerInternal(const FileTracker& parent_tracker,
                                              const std::string& file_id,
                                              const FileDetails* details,
                                              UpdateOption option) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   int64 tracker_id = IncrementTrackerID();
   scoped_ptr<FileTracker> tracker(new FileTracker);
   tracker->set_tracker_id(tracker_id);
   tracker->set_parent_tracker_id(parent_tracker.tracker_id());
   tracker->set_file_id(file_id);
   tracker->set_app_id(parent_tracker.app_id());
   tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   tracker->set_dirty(true);
   tracker->set_active(false);
   tracker->set_needs_folder_listing(false);
   if (details) {
     *tracker->mutable_synced_details() = *details;
     if (option == UPDATE_TRACKER_FOR_UNSYNCED_FILE) {
       tracker->mutable_synced_details()->set_missing(true);
       tracker->mutable_synced_details()->clear_md5();
     }
   }
   index_->StoreFileTracker(tracker.Pass());
 }
 
 void MetadataDatabase::MaybeAddTrackersForNewFile(
     const FileMetadata& metadata,
     UpdateOption option) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   std::set<int64> parents_to_exclude;
   TrackerIDSet existing_trackers =
       index_->GetFileTrackerIDsByFileID(metadata.file_id());
   for (TrackerIDSet::const_iterator itr = existing_trackers.begin();
        itr != existing_trackers.end(); ++itr) {
     FileTracker tracker;
     if (!index_->GetFileTracker(*itr, &tracker)) {
       NOTREACHED();
       continue;
     }
@@ skipping 24 matching lines @@
       if (ContainsKey(parents_to_exclude, parent_tracker.tracker_id()))
         continue;
 
       CreateTrackerForParentAndFileMetadata(
           parent_tracker, metadata, option);
     }
   }
 }
 
 int64 MetadataDatabase::IncrementTrackerID() {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   int64 tracker_id = index_->GetNextTrackerID();
   index_->SetNextTrackerID(tracker_id + 1);
   DCHECK_GT(tracker_id, 0);
   return tracker_id;
 }
 
 bool MetadataDatabase::CanActivateTracker(const FileTracker& tracker) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!tracker.active());
   DCHECK_NE(index_->GetSyncRootTrackerID(), tracker.tracker_id());
 
   if (HasActiveTrackerForFileID(tracker.file_id()))
     return false;
 
   if (tracker.app_id().empty() &&
       tracker.tracker_id() != GetSyncRootTrackerID()) {
     return false;
   }
 
   if (!tracker.has_synced_details())
     return false;
   if (tracker.synced_details().file_kind() == FILE_KIND_UNSUPPORTED)
     return false;
   if (HasInvalidTitle(tracker.synced_details().title()))
     return false;
   DCHECK(tracker.parent_tracker_id());
 
   return !HasActiveTrackerForPath(tracker.parent_tracker_id(),
                                   tracker.synced_details().title());
 }
 
 bool MetadataDatabase::ShouldKeepDirty(const FileTracker& tracker) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   if (HasDisabledAppRoot(tracker))
     return false;
 
   DCHECK(tracker.dirty());
   if (!tracker.has_synced_details())
     return true;
 
   FileMetadata metadata;
   if (!index_->GetFileMetadata(tracker.file_id(), &metadata))
     return true;
@@ skipping 11 matching lines @@
       return true;
   }
 
   if (local_details.title() != remote_details.title())
     return true;
 
   return false;
 }
 
 bool MetadataDatabase::HasDisabledAppRoot(const FileTracker& tracker) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   int64 app_root_tracker_id = index_->GetAppRootTracker(tracker.app_id());
   if (app_root_tracker_id == kInvalidTrackerID)
     return false;
 
   FileTracker app_root_tracker;
   if (!index_->GetFileTracker(app_root_tracker_id, &app_root_tracker)) {
     NOTREACHED();
     return false;
   }
   return app_root_tracker.tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT;
 }
 
 bool MetadataDatabase::HasActiveTrackerForFileID(
     const std::string& file_id) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->GetFileTrackerIDsByFileID(file_id).has_active();
 }
 
 bool MetadataDatabase::HasActiveTrackerForPath(int64 parent_tracker_id,
                                                const std::string& title) const {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   return index_->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title)
       .has_active();
 }
 
 void MetadataDatabase::RemoveUnneededTrackersForMissingFile(
     const std::string& file_id) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
     FileTracker tracker;
     if (!index_->GetFileTracker(*itr, &tracker)) {
       NOTREACHED();
       continue;
     }
 
     if (!tracker.has_synced_details() || tracker.synced_details().missing()) {
       RemoveFileTracker(*itr, MARK_NOTHING_DIRTY, index_.get());
     }
   }
 }
 
 void MetadataDatabase::UpdateByFileMetadata(
     const tracked_objects::Location& from_where,
     scoped_ptr<FileMetadata> metadata,
     UpdateOption option) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(metadata);
   DCHECK(metadata->has_details());
 
   DVLOG(1) << from_where.function_name() << ": "
            << metadata->file_id() << " ("
            << metadata->details().title() << ")"
            << (metadata->details().missing() ? " deleted" : "");
 
   std::string file_id = metadata->file_id();
   if (metadata->details().missing())
     RemoveUnneededTrackersForMissingFile(file_id);
   else
     MaybeAddTrackersForNewFile(*metadata, option);
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   if (!trackers.empty()) {
     index_->StoreFileMetadata(metadata.Pass());
 
     if (option != UPDATE_TRACKER_FOR_SYNCED_FILE)
       MarkTrackerSetDirty(trackers, index_.get());
   }
 }
 
 void MetadataDatabase::WriteToDatabase(const SyncStatusCallback& callback) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   leveldb::Status status = db_->Commit();
   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))
     return files.Pass();
 
   std::vector<int64> stack;
   AppendContents(
       index_->GetFileTrackerIDsByParent(app_root_tracker.tracker_id()), &stack);
   while (!stack.empty()) {
@@ skipping 26 matching lines @@
 
     file->Set("details", details);
 
     files->Append(file);
   }
 
   return files.Pass();
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpDatabase() {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   scoped_ptr<base::ListValue> list(new base::ListValue);
   list->Append(DumpTrackers().release());
   list->Append(DumpMetadata().release());
   return list.Pass();
 }
 
 bool MetadataDatabase::HasNewerFileMetadata(const std::string& file_id,
                                             int64 change_id) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   FileMetadata metadata;
   if (!index_->GetFileMetadata(file_id, &metadata))
     return false;
   DCHECK(metadata.has_details());
   return metadata.details().change_id() >= change_id;
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpTrackers() {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   scoped_ptr<base::ListValue> trackers(new base::ListValue);
 
   // Append the first element for metadata.
   base::DictionaryValue* metadata = new base::DictionaryValue;
   const char *trackerKeys[] = {
     "tracker_id", "path", "file_id", "tracker_kind", "app_id",
     "active", "dirty", "folder_listing",
     "title", "kind", "md5", "etag", "missing", "change_id",
   };
   std::vector<std::string> key_strings(
@@ skipping 40 matching lines @@
       dict->SetString("etag", details.etag());
       dict->SetString("missing", details.missing() ? "true" : "false");
       dict->SetString("change_id", base::Int64ToString(details.change_id()));
     }
     trackers->Append(dict);
   }
   return trackers.Pass();
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpMetadata() {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   scoped_ptr<base::ListValue> files(new base::ListValue);
 
   // Append the first element for metadata.
   base::DictionaryValue* metadata = new base::DictionaryValue;
   const char *fileKeys[] = {
     "file_id", "title", "type", "md5", "etag", "missing",
     "change_id", "parents"
   };
   std::vector<std::string> key_strings(
       fileKeys, fileKeys + ARRAYSIZE_UNSAFE(fileKeys));
@@ skipping 30 matching lines @@
         parents.push_back(details.parent_folder_ids(i));
       dict->SetString("parents", JoinString(parents, ","));
     }
     files->Append(dict);
   }
   return files.Pass();
 }
 
 void MetadataDatabase::AttachSyncRoot(
     const google_apis::FileResource& sync_root_folder) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   scoped_ptr<FileMetadata> sync_root_metadata =
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), sync_root_folder);
   scoped_ptr<FileTracker> sync_root_tracker =
       CreateSyncRootTracker(IncrementTrackerID(), *sync_root_metadata);
 
   index_->SetSyncRootTrackerID(sync_root_tracker->tracker_id());
   index_->StoreFileMetadata(sync_root_metadata.Pass());
   index_->StoreFileTracker(sync_root_tracker.Pass());
 }
 
 void MetadataDatabase::AttachInitialAppRoot(
     const google_apis::FileResource& app_root_folder) {
   scoped_ptr<FileMetadata> app_root_metadata =
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), app_root_folder);
   scoped_ptr<FileTracker> app_root_tracker =
       CreateInitialAppRootTracker(IncrementTrackerID(),
                                   GetSyncRootTrackerID(),
                                   *app_root_metadata);
 
   index_->StoreFileMetadata(app_root_metadata.Pass());
   index_->StoreFileTracker(app_root_tracker.Pass());
 }
 
-void MetadataDatabase::DetachFromSequence() {
-  worker_sequence_checker_.DetachFromSequence();
-}
-
 bool MetadataDatabase::CanClearDirty(const FileTracker& tracker) {
-  DCHECK(worker_sequence_checker_.CalledOnValidSequencedThread());
-
   FileMetadata metadata;
   if (!index_->GetFileMetadata(tracker.file_id(), &metadata) ||
       !tracker.active() || !tracker.dirty() ||
       !tracker.has_synced_details() ||
       tracker.needs_folder_listing())
     return false;
 
   const FileDetails& remote_details = metadata.details();
   const FileDetails& synced_details = tracker.synced_details();
   if (remote_details.title() != synced_details.title() ||
@@ skipping 10 matching lines @@
       return false;
 
   if (!parents.empty())
     return false;
 
   return true;
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system