drive: Stop returning ResourceEntry from JobScheduler

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 "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
-#include "chrome/browser/chromeos/drive/file_system_util.h"
-#include "chrome/browser/drive/drive_api_util.h"
 #include "chrome/browser/drive/event_logger.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/drive/drive_api_parser.h"
-#include "google_apis/drive/gdata_wapi_parser.h"
 
 using content::BrowserThread;
 
 namespace drive {
 
 namespace {
 
 // All jobs are retried at maximum of kMaxRetryCount when they fail due to
 // throttling or server error.  The delay before retrying a job is shared among
 // jobs. It doubles in length on each failure, upto 2^kMaxThrottleCount seconds.
@@ skipping 345 matching lines @@
       base::Unretained(drive_service_),
       next_link,
       base::Bind(&JobScheduler::OnGetFileListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
-void JobScheduler::GetResourceEntry(
+void JobScheduler::GetFileResource(
     const std::string& resource_id,
     const ClientContext& context,
-    const google_apis::GetResourceEntryCallback& callback) {
+    const google_apis::FileResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_RESOURCE_ENTRY);
   new_job->context = context;
   new_job->task = base::Bind(
       &DriveServiceInterface::GetFileResource,
       base::Unretained(drive_service_),
       resource_id,
       base::Bind(&JobScheduler::OnGetFileResourceJobDone,
@@ skipping 46 matching lines @@
                  callback));
   new_job->abort_callback = callback;
   StartJob(new_job);
 }
 
 void JobScheduler::CopyResource(
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& new_title,
     const base::Time& last_modified,
-    const google_apis::GetResourceEntryCallback& callback) {
+    const google_apis::FileResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_COPY_RESOURCE);
   new_job->task = base::Bind(
       &DriveServiceInterface::CopyResource,
       base::Unretained(drive_service_),
       resource_id,
       parent_resource_id,
       new_title,
       last_modified,
       base::Bind(&JobScheduler::OnGetFileResourceJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
   new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::UpdateResource(
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& new_title,
     const base::Time& last_modified,
     const base::Time& last_viewed_by_me,
     const ClientContext& context,
-    const google_apis::GetResourceEntryCallback& callback) {
+    const google_apis::FileResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_UPDATE_RESOURCE);
   new_job->context = context;
   new_job->task = base::Bind(
       &DriveServiceInterface::UpdateResource,
       base::Unretained(drive_service_),
       resource_id,
       parent_resource_id,
@@ skipping 70 matching lines @@
                  callback));
   new_job->abort_callback = callback;
   StartJob(new_job);
 }
 
 void JobScheduler::AddNewDirectory(
     const std::string& parent_resource_id,
     const std::string& directory_title,
     const DriveServiceInterface::AddNewDirectoryOptions& options,
     const ClientContext& context,
-    const google_apis::GetResourceEntryCallback& callback) {
+    const google_apis::FileResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   JobEntry* new_job = CreateNewJob(TYPE_ADD_NEW_DIRECTORY);
   new_job->context = context;
   new_job->task = base::Bind(
       &DriveServiceInterface::AddNewDirectory,
       base::Unretained(drive_service_),
       parent_resource_id,
       directory_title,
       options,
@@ skipping 38 matching lines @@
 }
 
 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 DriveUploader::UploadNewFileOptions& options,
     const ClientContext& context,
-    const google_apis::GetResourceEntryCallback& callback) {
+    const google_apis::FileResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   JobEntry* new_job = CreateNewJob(TYPE_UPLOAD_NEW_FILE);
   new_job->job_info.file_path = drive_file_path;
   new_job->context = context;
 
   UploadNewFileParams params;
   params.parent_resource_id = parent_resource_id;
   params.local_file_path = local_file_path;
   params.title = title;
@@ skipping 17 matching lines @@
   StartJob(new_job);
 }
 
 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 DriveUploader::UploadExistingFileOptions& options,
     const ClientContext& context,
-    const google_apis::GetResourceEntryCallback& callback) {
+    const google_apis::FileResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   JobEntry* new_job = CreateNewJob(TYPE_UPLOAD_EXISTING_FILE);
   new_job->job_info.file_path = drive_file_path;
   new_job->context = context;
 
   UploadExistingFileParams params;
   params.resource_id = resource_id;
   params.local_file_path = local_file_path;
   params.content_type = content_type;
@@ skipping 238 matching lines @@
     scoped_ptr<google_apis::ChangeList> change_list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (OnJobDone(job_id, error))
     callback.Run(error, change_list.Pass());
 }
 
 void JobScheduler::OnGetFileResourceJobDone(
     JobID job_id,
-    const google_apis::GetResourceEntryCallback& callback,
+    const google_apis::FileResourceCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::FileResource> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (OnJobDone(job_id, error)) {
-    callback.Run(error, entry ?
-                 util::ConvertFileResourceToResourceEntry(*entry) :
-                 scoped_ptr<google_apis::ResourceEntry>());
-  }
+  if (OnJobDone(job_id, error))
+    callback.Run(error, entry.Pass());
 }
 
 void JobScheduler::OnGetAboutResourceJobDone(
     JobID job_id,
     const google_apis::AboutResourceCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::AboutResource> about_resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
@@ skipping 44 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (OnJobDone(job_id, error))
     callback.Run(error, temp_file);
 }
 
 void JobScheduler::OnUploadCompletionJobDone(
     JobID job_id,
     const ResumeUploadParams& resume_params,
-    const google_apis::GetResourceEntryCallback& callback,
+    const google_apis::FileResourceCallback& callback,
     google_apis::GDataErrorCode error,
     const GURL& upload_location,
     scoped_ptr<google_apis::FileResource> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (!upload_location.is_empty()) {
     // If upload_location is available, update the task to resume the
     // upload process from the terminated point.
     // When we need to retry, the error code should be HTTP_SERVICE_UNAVAILABLE
     // so OnJobDone called below will be in charge to re-queue the job.
     JobEntry* job_entry = job_map_.Lookup(job_id);
     DCHECK(job_entry);
 
     ResumeUploadFileParams params;
     params.upload_location = upload_location;
     params.local_file_path = resume_params.local_file_path;
     params.content_type = resume_params.content_type;
     params.callback = base::Bind(&JobScheduler::OnResumeUploadFileDone,
                                  weak_ptr_factory_.GetWeakPtr(),
                                  job_id,
                                  job_entry->task,
                                  callback);
     params.progress_callback = base::Bind(&JobScheduler::UpdateProgress,
                                           weak_ptr_factory_.GetWeakPtr(),
                                           job_id);
     job_entry->task = base::Bind(&RunResumeUploadFile, uploader_.get(), params);
   }
 
-  if (OnJobDone(job_id, error)) {
-    callback.Run(error, entry ?
-                 util::ConvertFileResourceToResourceEntry(*entry) :
-                 scoped_ptr<google_apis::ResourceEntry>());
-  }
+  if (OnJobDone(job_id, error))
+    callback.Run(error, entry.Pass());
 }
 
 void JobScheduler::OnResumeUploadFileDone(
     JobID job_id,
     const base::Callback<google_apis::CancelCallback()>& original_task,
-    const google_apis::GetResourceEntryCallback& callback,
+    const google_apis::FileResourceCallback& callback,
     google_apis::GDataErrorCode error,
     const GURL& upload_location,
     scoped_ptr<google_apis::FileResource> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!original_task.is_null());
   DCHECK(!callback.is_null());
 
   if (upload_location.is_empty()) {
     // If upload_location is not available, we should discard it and stop trying
     // to resume. Restore the original task.
     JobEntry* job_entry = job_map_.Lookup(job_id);
     DCHECK(job_entry);
     job_entry->task = original_task;
   }
 
-  if (OnJobDone(job_id, error)) {
-    callback.Run(error, entry ?
-                 util::ConvertFileResourceToResourceEntry(*entry) :
-                 scoped_ptr<google_apis::ResourceEntry>());
-  }
+  if (OnJobDone(job_id, error))
+    callback.Run(error, entry.Pass());
 }
 
 void JobScheduler::UpdateProgress(JobID job_id, int64 progress, int64 total) {
   JobEntry* job_entry = job_map_.Lookup(job_id);
   DCHECK(job_entry);
 
   job_entry->job_info.num_completed_bytes = progress;
   if (total != -1)
     job_entry->job_info.num_total_bytes = total;
   NotifyJobUpdated(job_entry->job_info);
@@ skipping 93 matching lines @@
     case FILE_QUEUE:
       return "FILE_QUEUE";
     case NUM_QUEUES:
       break;  // This value is just a sentinel. Should never be used.
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace drive