[SyncFS] Drop default priority version of SyncTaskManager::ScheduleTask

chrome/browser/sync_file_system/drive_backend/sync_engine.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/sync_engine.h"
 
 #include "base/bind.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/drive/drive_api_service.h"
@@ skipping 146 matching lines @@
     const SyncStatusCallback& callback) {
   if (!metadata_database_ && drive_service_->HasRefreshToken())
     PostInitializeTask();
 
   scoped_ptr<RegisterAppTask> task(new RegisterAppTask(this, origin.host()));
   if (task->CanFinishImmediately()) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
-  task_manager_->ScheduleSyncTaskAtPriority(
+  task_manager_->ScheduleSyncTask(
       FROM_HERE,
       task.PassAs<SyncTask>(),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncEngine::EnableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
-  task_manager_->ScheduleTaskAtPriority(
+  task_manager_->ScheduleTask(
       FROM_HERE,
       base::Bind(&SyncEngine::DoEnableApp,
                  weak_ptr_factory_.GetWeakPtr(),
                  origin.host()),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncEngine::DisableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
-  task_manager_->ScheduleTaskAtPriority(
+  task_manager_->ScheduleTask(
       FROM_HERE,
       base::Bind(&SyncEngine::DoDisableApp,
                  weak_ptr_factory_.GetWeakPtr(),
                  origin.host()),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncEngine::UninstallOrigin(
     const GURL& origin,
     UninstallFlag flag,
     const SyncStatusCallback& callback) {
-  task_manager_->ScheduleSyncTaskAtPriority(
+  task_manager_->ScheduleSyncTask(
       FROM_HERE,
       scoped_ptr<SyncTask>(new UninstallAppTask(this, origin.host(), flag)),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncEngine::ProcessRemoteChange(
     const SyncFileCallback& callback) {
   RemoteToLocalSyncer* syncer = new RemoteToLocalSyncer(this);
   task_manager_->ScheduleSyncTask(
       FROM_HERE,
       scoped_ptr<SyncTask>(syncer),
+      SyncTaskManager::PRIORITY_MED,
       base::Bind(&SyncEngine::DidProcessRemoteChange,
                  weak_ptr_factory_.GetWeakPtr(),
                  syncer, callback));
 }
 
 void SyncEngine::SetRemoteChangeProcessor(
     RemoteChangeProcessor* processor) {
   remote_change_processor_ = processor;
 }
 
@@ skipping 112 matching lines @@
     const FileChange& local_change,
     const base::FilePath& local_path,
     const SyncFileMetadata& local_metadata,
     const fileapi::FileSystemURL& url,
     const SyncStatusCallback& callback) {
   LocalToRemoteSyncer* syncer = new LocalToRemoteSyncer(
       this, local_metadata, local_change, local_path, url);
   task_manager_->ScheduleSyncTask(
       FROM_HERE,
       scoped_ptr<SyncTask>(syncer),
+      SyncTaskManager::PRIORITY_MED,
       base::Bind(&SyncEngine::DidApplyLocalChange,
                  weak_ptr_factory_.GetWeakPtr(),
                  syncer, callback));
 }
 
 void SyncEngine::MaybeScheduleNextTask() {
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED)
     return;
 
   // TODO(tzik): Notify observer of OnRemoteChangeQueueUpdated.
@@ skipping 133 matching lines @@
   DCHECK(!metadata_database_);
 
   // This initializer task may not run if metadata_database_ is already
   // initialized when it runs.
   SyncEngineInitializer* initializer =
       new SyncEngineInitializer(this,
                                 task_runner_.get(),
                                 drive_service_.get(),
                                 base_dir_.Append(kDatabaseName),
                                 env_override_);
-  task_manager_->ScheduleSyncTaskAtPriority(
+  task_manager_->ScheduleSyncTask(
       FROM_HERE,
       scoped_ptr<SyncTask>(initializer),
       SyncTaskManager::PRIORITY_HIGH,
       base::Bind(&SyncEngine::DidInitialize, weak_ptr_factory_.GetWeakPtr(),
                  initializer));
 }
 
 void SyncEngine::DidInitialize(SyncEngineInitializer* initializer,
                                SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
@@ skipping 66 matching lines @@
                                           SYNC_DIRECTION_LOCAL_TO_REMOTE));
   }
 
   if (status == SYNC_STATUS_UNKNOWN_ORIGIN && syncer->url().is_valid()) {
     RegisterOrigin(syncer->url().origin(),
                    base::Bind(&EmptyStatusCallback));
   }
 
   if (syncer->needs_remote_change_listing() &&
       !listing_remote_changes_) {
-    task_manager_->ScheduleSyncTaskAtPriority(
+    task_manager_->ScheduleSyncTask(
         FROM_HERE,
         scoped_ptr<SyncTask>(new ListChangesTask(this)),
         SyncTaskManager::PRIORITY_HIGH,
         base::Bind(&SyncEngine::DidFetchChanges,
                    weak_ptr_factory_.GetWeakPtr()));
     should_check_remote_change_ = false;
     listing_remote_changes_ = true;
     time_to_check_changes_ =
         base::TimeTicks::Now() +
         base::TimeDelta::FromSeconds(kListChangesRetryDelaySeconds);
@@ skipping 155 matching lines @@
         tracker.tracker_kind() == TRACKER_KIND_APP_ROOT;
     if (is_app_enabled && !is_app_root_tracker_enabled)
       EnableOrigin(origin, base::Bind(&EmptyStatusCallback));
     else if (!is_app_enabled && is_app_root_tracker_enabled)
       DisableOrigin(origin, base::Bind(&EmptyStatusCallback));
   }
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system