drive: Rename JobScheduler::QueueEntry to JobEntry

chrome/browser/chromeos/drive/job_scheduler.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/job_scheduler.h"
 
 #include <math.h>
 
 #include "base/message_loop.h"
 #include "base/prefs/pref_service.h"
@@ skipping 15 matching lines @@
 
 namespace {
 const int kMaxThrottleCount = 5;
 }
 
 const int JobScheduler::kMaxJobCount[] = {
   5,  // METADATA_QUEUE
   1,  // FILE_QUEUE
 };
 
-JobScheduler::QueueEntry::QueueEntry()
-    : job_id(-1),
+JobScheduler::JobEntry::JobEntry(JobType type)
+    : job_info(type),
       context(DriveClientContext(USER_INITIATED)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
-JobScheduler::QueueEntry::~QueueEntry() {
+JobScheduler::JobEntry::~JobEntry() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
-bool JobScheduler::QueueEntry::Compare(
-    const JobScheduler::QueueEntry* left,
-    const JobScheduler::QueueEntry* right) {
+bool JobScheduler::JobEntry::Less(const JobEntry& left, const JobEntry& right) {
   // Lower values of ContextType are higher priority.
   // See also the comment at ContextType.
-  return (left->context.type < right->context.type);
+  return (left.context.type < right.context.type);
 }
 
 JobScheduler::JobScheduler(
     Profile* profile,
     google_apis::DriveServiceInterface* drive_service)
     : throttle_count_(0),
       disable_throttling_(false),
       drive_service_(drive_service),
       uploader_(new google_apis::DriveUploader(drive_service)),
       profile_(profile),
@@ skipping 10 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   size_t num_pending_jobs = 0;
   size_t num_running_jobs = 0;
   for (int i = 0; i < NUM_QUEUES; ++i) {
     num_pending_jobs += queue_[i].size();
     num_running_jobs += jobs_running_[i];
   }
   DCHECK_EQ(num_pending_jobs + num_running_jobs, job_map_.size());
 
-  for (int i = 0; i < NUM_QUEUES; ++i) {
-    STLDeleteElements(&queue_[i]);
-  }
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
 std::vector<JobInfo> JobScheduler::GetJobInfoList() {
   std::vector<JobInfo> job_info_list;
   for (JobIDMap::iterator iter(&job_map_); !iter.IsAtEnd(); iter.Advance())
-    job_info_list.push_back(*iter.GetCurrentValue());
+    job_info_list.push_back(iter.GetCurrentValue()->job_info);
   return job_info_list;
 }
 
 void JobScheduler::AddObserver(JobListObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observer_list_.AddObserver(observer);
 }
 
 void JobScheduler::RemoveObserver(JobListObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observer_list_.RemoveObserver(observer);
 }
 
 void JobScheduler::CancelJob(JobID job_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // TODO(kinaba): Move the cancellation feature from DriveService
   // to JobScheduler. In particular, implement cancel based on job_id.
   // crbug.com/231029
-  JobInfo* info = job_map_.Lookup(job_id);
-  if (info)
-    drive_service_->CancelForFilePath(info->file_path);
+  JobEntry* job = job_map_.Lookup(job_id);
+  if (job)
+    drive_service_->CancelForFilePath(job->job_info.file_path);
 }
 
 void JobScheduler::CancelAllJobs() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // TODO(kinaba): Move the cancellation feature from DriveService
   // to JobScheduler.
   drive_service_->CancelAll();
 }
 
 void JobScheduler::GetAccountMetadata(
     const google_apis::GetAccountMetadataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_GET_ACCOUNT_METADATA));
   new_job->get_account_metadata_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_GET_ACCOUNT_METADATA);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::GetAboutResource(
     const google_apis::GetAboutResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_GET_ABOUT_RESOURCE));
   new_job->get_about_resource_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_GET_ABOUT_RESOURCE);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::GetAppList(
     const google_apis::GetAppListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_GET_APP_LIST));
   new_job->get_app_list_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_GET_APP_LIST);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::GetAllResourceList(
     const google_apis::GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_GET_ALL_RESOURCE_LIST));
   new_job->get_resource_list_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_GET_ALL_RESOURCE_LIST);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::GetResourceListInDirectory(
     const std::string& directory_resource_id,
     const google_apis::GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(
+      TYPE_GET_RESOURCE_LIST_IN_DIRECTORY));
   new_job->directory_resource_id = directory_resource_id;
   new_job->get_resource_list_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_GET_RESOURCE_LIST_IN_DIRECTORY);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::Search(
     const std::string& search_query,
     const google_apis::GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_SEARCH));
   new_job->search_query = search_query;
   new_job->get_resource_list_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_SEARCH);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::GetChangeList(
     int64 start_changestamp,
     const google_apis::GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_GET_CHANGE_LIST));
   new_job->start_changestamp = start_changestamp;
   new_job->get_resource_list_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_GET_CHANGE_LIST);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::ContinueGetResourceList(
     const GURL& feed_url,
     const google_apis::GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_CONTINUE_GET_RESOURCE_LIST));
   new_job->feed_url = feed_url;
   new_job->get_resource_list_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_CONTINUE_GET_RESOURCE_LIST);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::GetResourceEntry(
     const std::string& resource_id,
     const DriveClientContext& context,
     const google_apis::GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_GET_RESOURCE_ENTRY));
   new_job->resource_id = resource_id;
   new_job->context = context;
   new_job->get_resource_entry_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_GET_RESOURCE_ENTRY);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::DeleteResource(
     const std::string& resource_id,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_DELETE_RESOURCE));
   new_job->resource_id = resource_id;
   new_job->entry_action_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_DELETE_RESOURCE);
+  StartNewJob(new_job.Pass());
 }
 
 
 void JobScheduler::CopyHostedDocument(
     const std::string& resource_id,
     const std::string& new_name,
     const google_apis::GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_COPY_HOSTED_DOCUMENT));
   new_job->resource_id = resource_id;
   new_job->new_name = new_name;
   new_job->get_resource_entry_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_COPY_HOSTED_DOCUMENT);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::RenameResource(
     const std::string& resource_id,
     const std::string& new_name,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_RENAME_RESOURCE));
   new_job->resource_id = resource_id;
   new_job->new_name = new_name;
   new_job->entry_action_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_RENAME_RESOURCE);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::AddResourceToDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_ADD_RESOURCE_TO_DIRECTORY));
   new_job->parent_resource_id = parent_resource_id;
   new_job->resource_id = resource_id;
   new_job->entry_action_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_ADD_RESOURCE_TO_DIRECTORY);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::RemoveResourceFromDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(
+      TYPE_REMOVE_RESOURCE_FROM_DIRECTORY));
   new_job->parent_resource_id = parent_resource_id;
   new_job->resource_id = resource_id;
   new_job->entry_action_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_REMOVE_RESOURCE_FROM_DIRECTORY);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::AddNewDirectory(
     const std::string& parent_resource_id,
     const std::string& directory_name,
     const google_apis::GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_ADD_NEW_DIRECTORY));
   new_job->parent_resource_id = parent_resource_id;
   new_job->directory_name = directory_name;
   new_job->get_resource_entry_callback = callback;
 
-  StartNewJob(new_job.Pass(), TYPE_ADD_NEW_DIRECTORY);
+  StartNewJob(new_job.Pass());
 }
 
 JobID JobScheduler::DownloadFile(
     const base::FilePath& virtual_path,
     const base::FilePath& local_cache_path,
     const GURL& download_url,
     const DriveClientContext& context,
     const google_apis::DownloadActionCallback& download_action_callback,
     const google_apis::GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_DOWNLOAD_FILE));
   new_job->drive_file_path = virtual_path;
   new_job->local_file_path = local_cache_path;
   new_job->download_url = download_url;
   new_job->context = context;
   new_job->download_action_callback = download_action_callback;
   new_job->get_content_callback = get_content_callback;
 
-  return StartNewJob(new_job.Pass(), TYPE_DOWNLOAD_FILE);
+  return StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::UploadNewFile(
     const std::string& parent_resource_id,
     const base::FilePath& drive_file_path,
     const base::FilePath& local_file_path,
     const std::string& title,
     const std::string& content_type,
     const DriveClientContext& context,
     const google_apis::UploadCompletionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_UPLOAD_NEW_FILE));
   new_job->resource_id = parent_resource_id;
   new_job->drive_file_path = drive_file_path;
   new_job->local_file_path = local_file_path;
   new_job->title = title;
   new_job->content_type = content_type;
   new_job->upload_completion_callback = callback;
   new_job->context = context;
 
-  StartNewJob(new_job.Pass(), TYPE_UPLOAD_NEW_FILE);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::UploadExistingFile(
     const std::string& resource_id,
     const base::FilePath& drive_file_path,
     const base::FilePath& local_file_path,
     const std::string& content_type,
     const std::string& etag,
     const DriveClientContext& context,
     const google_apis::UploadCompletionCallback& upload_completion_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_UPLOAD_EXISTING_FILE));
   new_job->resource_id = resource_id;
   new_job->drive_file_path = drive_file_path;
   new_job->local_file_path = local_file_path;
   new_job->content_type = content_type;
   new_job->etag = etag;
   new_job->upload_completion_callback = upload_completion_callback;
   new_job->context = context;
 
-  StartNewJob(new_job.Pass(), TYPE_UPLOAD_EXISTING_FILE);
+  StartNewJob(new_job.Pass());
 }
 
 void JobScheduler::CreateFile(
     const std::string& parent_resource_id,
     const base::FilePath& drive_file_path,
     const std::string& title,
     const std::string& content_type,
     const DriveClientContext& context,
     const google_apis::UploadCompletionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  scoped_ptr<QueueEntry> new_job(new QueueEntry);
+  scoped_ptr<JobEntry> new_job(new JobEntry(TYPE_CREATE_FILE));
   new_job->resource_id = parent_resource_id;
   new_job->drive_file_path = drive_file_path;
   new_job->title = title;
   new_job->content_type = content_type;
   new_job->upload_completion_callback = callback;
   new_job->context = context;
 
-  StartNewJob(new_job.Pass(), TYPE_CREATE_FILE);
+  StartNewJob(new_job.Pass());
 }
 
-JobID JobScheduler::StartNewJob(scoped_ptr<QueueEntry> job, JobType type) {
-  // job_info is owned by job_map_ and released when it is removed in OnJobDone.
-  JobInfo* job_info = new JobInfo(type);
-  job->job_id = job_info->job_id = job_map_.Add(job_info);
+JobID JobScheduler::StartNewJob(scoped_ptr<JobEntry> job) {
+  DCHECK(job);
+
+  // |job| is owned by job_map_ and released when it is removed in OnJobDone.
+  JobInfo* job_info = &job->job_info;
   job_info->file_path = job->drive_file_path;
+  job_info->job_id = job_map_.Add(job.release());
 
-  QueueJob(job.Pass());
+  QueueJob(job_info->job_id);
   NotifyJobAdded(*job_info);
-  StartJobLoop(GetJobQueueType(type));
+  StartJobLoop(GetJobQueueType(job_info->job_type));
   return job_info->job_id;
 }
 
-void JobScheduler::QueueJob(scoped_ptr<QueueEntry> job) {
+void JobScheduler::QueueJob(JobID job_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  JobInfo* job_info = job_map_.Lookup(job->job_id);
-  DCHECK(job_info);
+  JobEntry* job_entry = job_map_.Lookup(job_id);
+  DCHECK(job_entry);
+  const JobInfo& job_info = job_entry->job_info;
 
-  QueueType queue_type = GetJobQueueType(job_info->job_type);
-  std::list<QueueEntry*>& queue = queue_[queue_type];
+  QueueType queue_type = GetJobQueueType(job_info.job_type);
+  std::list<JobID>* queue = &queue_[queue_type];
 
-  queue.push_back(job.release());
-  queue.sort(&QueueEntry::Compare);
+  std::list<JobID>::iterator it = queue->begin();
+  for (; it != queue->end(); ++it) {
+    JobEntry* job_entry2 = job_map_.Lookup(*it);
+    if (JobEntry::Less(*job_entry, *job_entry2))
+      break;
+  }
+  queue->insert(it, job_id);
 
-  util::Log("Job queued: %s - %s", job_info->ToString().c_str(),
+  util::Log("Job queued: %s - %s", job_info.ToString().c_str(),
             GetQueueInfo(queue_type).c_str());
 }
 
 void JobScheduler::StartJobLoop(QueueType queue_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (jobs_running_[queue_type] < kMaxJobCount[queue_type])
     DoJobLoop(queue_type);
 }
 
 void JobScheduler::DoJobLoop(QueueType queue_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (queue_[queue_type].empty()) {
     return;
   }
 
+  JobID job_id = queue_[queue_type].front();
+  JobEntry* entry = job_map_.Lookup(job_id);
+  DCHECK(entry);
+
   // Check if we should defer based on the first item in the queue
-  if (ShouldStopJobLoop(queue_type, queue_[queue_type].front()->context)) {
+  if (ShouldStopJobLoop(queue_type, entry->context)) {
     return;
   }
 
   // Increment the number of jobs.
   ++jobs_running_[queue_type];
 
-  // Should copy before calling queue_.pop_front().
-  scoped_ptr<QueueEntry> queue_entry(queue_[queue_type].front());
   queue_[queue_type].pop_front();
 
-  JobInfo* job_info = job_map_.Lookup(queue_entry->job_id);
-  DCHECK(job_info);
+  JobInfo* job_info = &entry->job_info;
   job_info->state = STATE_RUNNING;
   job_info->start_time = base::Time::Now();
   NotifyJobUpdated(*job_info);
 
-  // The some arguments are evaluated after bind, so we copy the pointer to the
-  // QueueEntry
-  QueueEntry* entry = queue_entry.get();
-
   switch (job_info->job_type) {
     case TYPE_GET_ABOUT_RESOURCE: {
       drive_service_->GetAboutResource(
           base::Bind(&JobScheduler::OnGetAboutResourceJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->get_about_resource_callback));
     }
     break;
 
     case TYPE_GET_ACCOUNT_METADATA: {
       drive_service_->GetAccountMetadata(
           base::Bind(&JobScheduler::OnGetAccountMetadataJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->get_account_metadata_callback));
     }
     break;
 
     case TYPE_GET_APP_LIST: {
       drive_service_->GetAppList(
           base::Bind(&JobScheduler::OnGetAppListJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->get_app_list_callback));
     }
     break;
 
     case TYPE_GET_ALL_RESOURCE_LIST: {
       drive_service_->GetAllResourceList(
           base::Bind(&JobScheduler::OnGetResourceListJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->get_resource_list_callback));
     }
     break;
 
     case TYPE_GET_RESOURCE_LIST_IN_DIRECTORY: {
       drive_service_->GetResourceListInDirectory(
           entry->directory_resource_id,
           base::Bind(&JobScheduler::OnGetResourceListJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->get_resource_list_callback));
     }
     break;
 
     case TYPE_SEARCH: {
       drive_service_->Search(
           entry->search_query,
           base::Bind(&JobScheduler::OnGetResourceListJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->get_resource_list_callback));
     }
     break;
 
     case TYPE_GET_CHANGE_LIST: {
       drive_service_->GetChangeList(
           entry->start_changestamp,
           base::Bind(&JobScheduler::OnGetResourceListJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->get_resource_list_callback));
     }
     break;
 
     case TYPE_CONTINUE_GET_RESOURCE_LIST: {
       drive_service_->ContinueGetResourceList(
           entry->feed_url,
           base::Bind(&JobScheduler::OnGetResourceListJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->get_resource_list_callback));
     }
     break;
 
     case TYPE_GET_RESOURCE_ENTRY: {
       drive_service_->GetResourceEntry(
           entry->resource_id,
           base::Bind(&JobScheduler::OnGetResourceEntryJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->get_resource_entry_callback));
     }
     break;
 
     case TYPE_DELETE_RESOURCE: {
       drive_service_->DeleteResource(
           entry->resource_id,
           "",  // etag
           base::Bind(&JobScheduler::OnEntryActionJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->entry_action_callback));
     }
     break;
 
     case TYPE_COPY_HOSTED_DOCUMENT: {
       drive_service_->CopyHostedDocument(
           entry->resource_id,
           entry->new_name,
           base::Bind(&JobScheduler::OnGetResourceEntryJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->get_resource_entry_callback));
     }
     break;
 
     case TYPE_RENAME_RESOURCE: {
       drive_service_->RenameResource(
           entry->resource_id,
           entry->new_name,
           base::Bind(&JobScheduler::OnEntryActionJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->entry_action_callback));
     }
     break;
 
     case TYPE_ADD_RESOURCE_TO_DIRECTORY: {
       drive_service_->AddResourceToDirectory(
           entry->parent_resource_id,
           entry->resource_id,
           base::Bind(&JobScheduler::OnEntryActionJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->entry_action_callback));
     }
     break;
 
     case TYPE_REMOVE_RESOURCE_FROM_DIRECTORY: {
       drive_service_->RemoveResourceFromDirectory(
           entry->parent_resource_id,
           entry->resource_id,
           base::Bind(&JobScheduler::OnEntryActionJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->entry_action_callback));
     }
     break;
 
     case TYPE_ADD_NEW_DIRECTORY: {
       drive_service_->AddNewDirectory(
           entry->parent_resource_id,
           entry->directory_name,
           base::Bind(&JobScheduler::OnGetResourceEntryJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)));
+                     job_id,
+                     entry->get_resource_entry_callback));
     }
     break;
 
     case TYPE_DOWNLOAD_FILE: {
       drive_service_->DownloadFile(
           entry->drive_file_path,
           entry->local_file_path,
           entry->download_url,
           base::Bind(&JobScheduler::OnDownloadActionJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)),
+                     job_id,
+                     entry->download_action_callback),
           entry->get_content_callback,
           base::Bind(&JobScheduler::UpdateProgress,
                      weak_ptr_factory_.GetWeakPtr(),
-                     job_info->job_id));
+                     job_id));
     }
     break;
 
     case TYPE_UPLOAD_NEW_FILE: {
       uploader_->UploadNewFile(
           entry->resource_id,
           entry->drive_file_path,
           entry->local_file_path,
           entry->title,
           entry->content_type,
           base::Bind(&JobScheduler::OnUploadCompletionJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)),
+                     job_id,
+                     entry->upload_completion_callback),
           base::Bind(&JobScheduler::UpdateProgress,
                      weak_ptr_factory_.GetWeakPtr(),
-                     job_info->job_id));
+                     job_id));
     }
     break;
 
     case TYPE_UPLOAD_EXISTING_FILE: {
       uploader_->UploadExistingFile(
           entry->resource_id,
           entry->drive_file_path,
           entry->local_file_path,
           entry->content_type,
           entry->etag,
           base::Bind(&JobScheduler::OnUploadCompletionJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)),
+                     job_id,
+                     entry->upload_completion_callback),
           base::Bind(&JobScheduler::UpdateProgress,
                      weak_ptr_factory_.GetWeakPtr(),
-                     job_info->job_id));
+                     job_id));
     }
     break;
 
     case TYPE_CREATE_FILE: {
       // For now, creation is implemented by uploading an empty file /dev/null.
       // TODO(kinaba): http://crbug.com/135143. Implement in a nicer way.
       uploader_->UploadNewFile(
           entry->resource_id,
           entry->drive_file_path,
           base::FilePath(util::kSymLinkToDevNull),
           entry->title,
           entry->content_type,
           base::Bind(&JobScheduler::OnUploadCompletionJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(&queue_entry)),
+                     job_id,
+                     entry->upload_completion_callback),
           google_apis::ProgressCallback());
     }
     break;
 
     // There is no default case so that there will be a compiler error if a type
     // is added but unhandled.
   }
 
   util::Log("Job started: %s - %s",
             job_info->ToString().c_str(),
@@ skipping 64 matching lines @@
 
   // Post a task to continue the job loop.  This allows us to finish handling
   // the current job before starting the next one.
   throttle_count_ = 0;
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
       base::Bind(&JobScheduler::DoJobLoop,
                  weak_ptr_factory_.GetWeakPtr(),
                  queue_type));
 }
 
-bool JobScheduler::OnJobDone(scoped_ptr<JobScheduler::QueueEntry> queue_entry,
-                             FileError error) {
+bool JobScheduler::OnJobDone(JobID job_id, FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  JobInfo* job_info = job_map_.Lookup(queue_entry->job_id);
-  DCHECK(job_info);
+  JobEntry* job_entry = job_map_.Lookup(job_id);
+  DCHECK(job_entry);
+  JobInfo* job_info = &job_entry->job_info;
   QueueType queue_type = GetJobQueueType(job_info->job_type);
 
   const base::TimeDelta elapsed = base::Time::Now() - job_info->start_time;
   util::Log("Job done: %s => %s (elapsed time: %sms) - %s",
             job_info->ToString().c_str(),
             FileErrorToString(error).c_str(),
             base::Int64ToString(elapsed.InMilliseconds()).c_str(),
             GetQueueInfo(queue_type).c_str());
 
   // Decrement the number of jobs for this queue.
   --jobs_running_[queue_type];
 
   // Retry, depending on the error.
   if (error == FILE_ERROR_THROTTLED) {
     job_info->state = STATE_RETRY;
     NotifyJobUpdated(*job_info);
 
     // Requeue the job.
-    QueueJob(queue_entry.Pass());
+    QueueJob(job_id);
 
     ThrottleAndContinueJobLoop(queue_type);
     return false;
   } else {
     NotifyJobDone(*job_info, error);
     // The job has finished, no retry will happen in the scheduler. Now we can
     // remove the job info from the map. This is the only place of the removal.
-    job_map_.Remove(queue_entry->job_id);
+    job_map_.Remove(job_id);
 
     ResetThrottleAndContinueJobLoop(queue_type);
     return true;
   }
 }
 
 void JobScheduler::OnGetResourceListJobDone(
-    scoped_ptr<JobScheduler::QueueEntry> queue_entry,
+    JobID job_id,
+    const google_apis::GetResourceListCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceList> resource_list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!queue_entry->get_resource_list_callback.is_null());
+  DCHECK(!callback.is_null());
 
-  google_apis::GetResourceListCallback callback =
-      queue_entry->get_resource_list_callback;
-  if (OnJobDone(queue_entry.Pass(), util::GDataToFileError(error)))
+  if (OnJobDone(job_id, util::GDataToFileError(error)))
     callback.Run(error, resource_list.Pass());
 }
 
 void JobScheduler::OnGetResourceEntryJobDone(
-    scoped_ptr<JobScheduler::QueueEntry> queue_entry,
+    JobID job_id,
+    const google_apis::GetResourceEntryCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!queue_entry->get_resource_entry_callback.is_null());
+  DCHECK(!callback.is_null());
 
-  google_apis::GetResourceEntryCallback callback =
-      queue_entry->get_resource_entry_callback;
-  if (OnJobDone(queue_entry.Pass(), util::GDataToFileError(error)))
+  if (OnJobDone(job_id, util::GDataToFileError(error)))
     callback.Run(error, entry.Pass());
 }
 
 void JobScheduler::OnGetAboutResourceJobDone(
-    scoped_ptr<QueueEntry> queue_entry,
+    JobID job_id,
+    const google_apis::GetAboutResourceCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::AboutResource> about_resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!queue_entry->get_about_resource_callback.is_null());
+  DCHECK(!callback.is_null());
 
-  google_apis::GetAboutResourceCallback callback =
-      queue_entry->get_about_resource_callback;
-  if (OnJobDone(queue_entry.Pass(), util::GDataToFileError(error)))
+  if (OnJobDone(job_id, util::GDataToFileError(error)))
     callback.Run(error, about_resource.Pass());
 }
 
 void JobScheduler::OnGetAccountMetadataJobDone(
-    scoped_ptr<QueueEntry> queue_entry,
+    JobID job_id,
+    const google_apis::GetAccountMetadataCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::AccountMetadata> account_metadata) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!queue_entry->get_account_metadata_callback.is_null());
+  DCHECK(!callback.is_null());
 
-  google_apis::GetAccountMetadataCallback callback =
-      queue_entry->get_account_metadata_callback;
-  if (OnJobDone(queue_entry.Pass(), util::GDataToFileError(error)))
+  if (OnJobDone(job_id, util::GDataToFileError(error)))
     callback.Run(error, account_metadata.Pass());
 }
 
 void JobScheduler::OnGetAppListJobDone(
-    scoped_ptr<JobScheduler::QueueEntry> queue_entry,
+    JobID job_id,
+    const google_apis::GetAppListCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::AppList> app_list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!queue_entry->get_app_list_callback.is_null());
+  DCHECK(!callback.is_null());
 
-  google_apis::GetAppListCallback callback = queue_entry->get_app_list_callback;
-  if (OnJobDone(queue_entry.Pass(), util::GDataToFileError(error)))
+  if (OnJobDone(job_id, util::GDataToFileError(error)))
     callback.Run(error, app_list.Pass());
 }
 
 void JobScheduler::OnEntryActionJobDone(
-    scoped_ptr<JobScheduler::QueueEntry> queue_entry,
+    JobID job_id,
+    const google_apis::EntryActionCallback& callback,
     google_apis::GDataErrorCode error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!queue_entry->entry_action_callback.is_null());
+  DCHECK(!callback.is_null());
 
-  google_apis::EntryActionCallback callback =
-      queue_entry->entry_action_callback;
-  if (OnJobDone(queue_entry.Pass(), util::GDataToFileError(error)))
+  if (OnJobDone(job_id, util::GDataToFileError(error)))
     callback.Run(error);
 }
 
 void JobScheduler::OnDownloadActionJobDone(
-    scoped_ptr<JobScheduler::QueueEntry> queue_entry,
+    JobID job_id,
+    const google_apis::DownloadActionCallback& callback,
     google_apis::GDataErrorCode error,
     const base::FilePath& temp_file) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!queue_entry->download_action_callback.is_null());
+  DCHECK(!callback.is_null());
 
-  google_apis::DownloadActionCallback callback =
-      queue_entry->download_action_callback;
-  if (OnJobDone(queue_entry.Pass(), util::GDataToFileError(error)))
+  if (OnJobDone(job_id, util::GDataToFileError(error)))
     callback.Run(error, temp_file);
 }
 
 void JobScheduler::OnUploadCompletionJobDone(
-    scoped_ptr<QueueEntry> queue_entry,
+    JobID job_id,
+    const google_apis::UploadCompletionCallback& callback,
     google_apis::GDataErrorCode error,
     const base::FilePath& drive_path,
     const base::FilePath& file_path,
     scoped_ptr<google_apis::ResourceEntry> resource_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!queue_entry->upload_completion_callback.is_null());
+  DCHECK(!callback.is_null());
 
-  google_apis::UploadCompletionCallback callback =
-      queue_entry->upload_completion_callback;
-  if (OnJobDone(queue_entry.Pass(), util::GDataToFileError(error)))
+  if (OnJobDone(job_id, util::GDataToFileError(error)))
     callback.Run(error, drive_path, file_path, resource_entry.Pass());
 }
 
 void JobScheduler::UpdateProgress(JobID job_id, int64 progress, int64 total) {
-  JobInfo* job_info = job_map_.Lookup(job_id);
-  DCHECK(job_info);
+  JobEntry* job_entry = job_map_.Lookup(job_id);
+  DCHECK(job_entry);
 
-  job_info->num_completed_bytes = progress;
-  job_info->num_total_bytes = total;
-  NotifyJobUpdated(*job_info);
+  job_entry->job_info.num_completed_bytes = progress;
+  job_entry->job_info.num_total_bytes = total;
+  NotifyJobUpdated(job_entry->job_info);
 }
 
 void JobScheduler::OnConnectionTypeChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Resume the job loop if the network is back online. Note that we don't
   // need to check the type of the network as it will be checked in
   // ShouldStopJobLoop() as soon as the loop is resumed.
   if (!net::NetworkChangeNotifier::IsOffline()) {
@@ skipping 65 matching lines @@
       return "FILE_QUEUE";
     case NUM_QUEUES:
       return "NUM_QUEUES";
   }
   NOTREACHED();
   return "";
 }
 
 
 }  // namespace drive