drive: Rename DriveScheduler to JobScheduler

chrome/browser/chromeos/drive/file_system/move_operation.cc

 // Copyright (c) 2012 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/chromeos/drive/file_system/move_operation.h"
 
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_cache.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_util.h"
-#include "chrome/browser/chromeos/drive/drive_scheduler.h"
 #include "chrome/browser/chromeos/drive/file_system/operation_observer.h"
+#include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace drive {
 namespace file_system {
 
-MoveOperation::MoveOperation(DriveScheduler* drive_scheduler,
+MoveOperation::MoveOperation(JobScheduler* job_scheduler,
                              DriveResourceMetadata* metadata,
                              OperationObserver* observer)
-  : drive_scheduler_(drive_scheduler),
+  : job_scheduler_(job_scheduler),
     metadata_(metadata),
     observer_(observer),
     weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 MoveOperation::~MoveOperation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
@@ skipping 113 matching lines @@
     return;
   }
 
   // Drop the .g<something> extension from |new_name| if the file being
   // renamed is a hosted document and |new_name| has the same .g<something>
   // extension as the file.
   const base::FilePath& new_name_arg(
       new_name_has_hosted_extension ? new_name.RemoveExtension() : new_name);
 
   // Rename on the server.
-  drive_scheduler_->RenameResource(src_id,
-                                   new_name_arg.AsUTF8Unsafe(),
-                                   base::Bind(&MoveOperation::RenameLocally,
-                                              weak_ptr_factory_.GetWeakPtr(),
-                                              src_path,
-                                              new_name_arg,
-                                              callback));
+  job_scheduler_->RenameResource(src_id,
+                                 new_name_arg.AsUTF8Unsafe(),
+                                 base::Bind(&MoveOperation::RenameLocally,
+                                            weak_ptr_factory_.GetWeakPtr(),
+                                            src_path,
+                                            new_name_arg,
+                                            callback));
 }
 
 void MoveOperation::RenameLocally(const base::FilePath& src_path,
                                   const base::FilePath& new_name,
                                   const FileMoveCallback& callback,
                                   google_apis::GDataErrorCode status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const FileError error = util::GDataToFileError(status);
   if (error != FILE_ERROR_OK) {
     callback.Run(error, base::FilePath());
     return;
   }
   metadata_->RenameEntry(src_path, new_name.AsUTF8Unsafe(), callback);
 }
 
 
 void MoveOperation::AddToDirectory(const std::string& src_id,
                                    const std::string& dest_dir_id,
                                    const base::FilePath& src_path,
                                    const base::FilePath& dest_dir_path,
                                    const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  drive_scheduler_->AddResourceToDirectory(
+  job_scheduler_->AddResourceToDirectory(
       dest_dir_id, src_id,
       base::Bind(&MoveOperation::AddToDirectoryLocally,
                  weak_ptr_factory_.GetWeakPtr(),
                  src_path,
                  dest_dir_path,
                  callback));
 }
 
 void MoveOperation::AddToDirectoryLocally(const base::FilePath& src_path,
                                           const base::FilePath& dest_dir_path,
                                           const FileMoveCallback& callback,
                                           google_apis::GDataErrorCode status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const FileError error = util::GDataToFileError(status);
   if (error != FILE_ERROR_OK) {
     callback.Run(error, base::FilePath());
     return;
   }
   metadata_->MoveEntryToDirectory(src_path, dest_dir_path, callback);
 }
 
 void MoveOperation::RemoveFromDirectory(
     const std::string& resource_id,
     const std::string& directory_resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  drive_scheduler_->RemoveResourceFromDirectory(
+  job_scheduler_->RemoveResourceFromDirectory(
       directory_resource_id,
       resource_id,
       base::Bind(&MoveOperation::RemoveFromDirectoryCompleted,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void MoveOperation::RemoveFromDirectoryCompleted(
     const FileOperationCallback& callback,
     google_apis::GDataErrorCode status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   callback.Run(util::GDataToFileError(status));
 }
 
 }  // namespace file_system
 }  // namespace drive