Fill JobInfo in DriveScheduler.

chrome/browser/chromeos/drive/drive_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/drive_scheduler.h"
 
 #include <math.h>
 
 #include "base/message_loop.h"
 #include "base/prefs/pref_service.h"
@@ skipping 287 matching lines @@
 void DriveScheduler::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);
-  new_job->virtual_path = virtual_path;
-  new_job->local_cache_path = local_cache_path;
+  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;
 
   StartNewJob(new_job.Pass(), TYPE_DOWNLOAD_FILE);
 }
 
 void DriveScheduler::UploadNewFile(
     const std::string& parent_resource_id,
@@ skipping 36 matching lines @@
   new_job->upload_completion_callback = upload_completion_callback;
   new_job->context = context;
 
   StartNewJob(new_job.Pass(), TYPE_UPLOAD_EXISTING_FILE);
 }
 
 void DriveScheduler::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);
+  job_info->file_path = job->drive_file_path;

[hidehiko, 2013/04/17 06:23:21]

drive_file_path is only available for Upload/Download operations. Is it
expected? (i.e. will it be used only for these operations?)

[kinaba, 2013/04/17 06:41:01]

Thanks, good catch.
I haven't deeply thought about it but I want to make it as the expected
behavior,
because for many other operations Scheduler only known resource_id,
and intended clients are only interested in upload/download traffic.

Made in explicit in the comment of JobInfo.
Probably I should move to include only upload/download tasks in JobInfo in the
future.

 
   QueueJob(job.Pass());
   StartJobLoop(GetJobQueueType(type));
 }
 
 void DriveScheduler::QueueJob(scoped_ptr<QueueEntry> job) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   JobInfo* job_info = job_map_.Lookup(job->job_id);
   DCHECK(job_info);
@@ skipping 173 matching lines @@
           entry->parent_resource_id,
           entry->directory_name,
           base::Bind(&DriveScheduler::OnGetResourceEntryJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Passed(&queue_entry)));
     }
     break;
 
     case TYPE_DOWNLOAD_FILE: {
       drive_service_->DownloadFile(
-          entry->virtual_path,
-          entry->local_cache_path,
+          entry->drive_file_path,
+          entry->local_file_path,
           entry->download_url,
           base::Bind(&DriveScheduler::OnDownloadActionJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Passed(&queue_entry)),
           entry->get_content_callback,
-          google_apis::ProgressCallback());
+          base::Bind(&DriveScheduler::UpdateProgress,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     job_info->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(&DriveScheduler::OnUploadCompletionJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Passed(&queue_entry)),
-          google_apis::ProgressCallback());
+          base::Bind(&DriveScheduler::UpdateProgress,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     job_info->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(&DriveScheduler::OnUploadCompletionJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Passed(&queue_entry)),
-          google_apis::ProgressCallback());
+          base::Bind(&DriveScheduler::UpdateProgress,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     job_info->job_id));
     }
     break;
 
     // There is no default case so that there will be a compiler error if a type
     // is added but unhandled.
   }
 }
 
 bool DriveScheduler::ShouldStopJobLoop(QueueType queue_type,
                                        const DriveClientContext& context) {
@@ skipping 238 matching lines @@
 
   if (!queue_entry)
     return;
 
   // Handle the callback.
   DCHECK(!queue_entry->upload_completion_callback.is_null());
   queue_entry->upload_completion_callback.Run(
       error, drive_path, file_path, resource_entry.Pass());
 }
 
+void DriveScheduler::UpdateProgress(JobID job_id, int64 progress, int64 total) {
+  JobInfo* job_info = job_map_.Lookup(job_id);
+  DCHECK(job_info);
+
+  job_info->num_completed_bytes = progress;
+  job_info->num_total_bytes = total;
+}
+
 void DriveScheduler::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()) {
     for (int i = METADATA_QUEUE; i < NUM_QUEUES; ++i) {
       StartJobLoop(static_cast<QueueType>(i));
@@ skipping 38 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(JobListObserver, observer_list_, OnJobDone(job_info));
 }
 
 void DriveScheduler::NotifyJobUpdated(const JobInfo& job_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(JobListObserver, observer_list_, OnJobUpdated(job_info));
 }
 
 }  // namespace drive