Drive: Move inner structures of DriveAPIService under drive namespace.

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/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
@@ skipping 56 matching lines @@
 CreateErrorRunCallback(const base::Callback<CallbackType>& callback) {
   return base::Bind(&CreateErrorRunCallbackHelper<CallbackType>::Run, callback);
 }
 
 // Parameter struct for RunUploadNewFile.
 struct UploadNewFileParams {
   std::string parent_resource_id;
   base::FilePath local_file_path;
   std::string title;
   std::string content_type;
-  DriveUploader::UploadNewFileOptions options;
+  UploadNewFileOptions options;
   UploadCompletionCallback callback;
   google_apis::ProgressCallback progress_callback;
 };
 
 // Helper function to work around the arity limitation of base::Bind.
 google_apis::CancelCallback RunUploadNewFile(
     DriveUploaderInterface* uploader,
     const UploadNewFileParams& params) {
   return uploader->UploadNewFile(params.parent_resource_id,
                                  params.local_file_path,
                                  params.title,
                                  params.content_type,
                                  params.options,
                                  params.callback,
                                  params.progress_callback);
 }
 
 // Parameter struct for RunUploadExistingFile.
 struct UploadExistingFileParams {
   std::string resource_id;
   base::FilePath local_file_path;
   std::string content_type;
-  DriveUploader::UploadExistingFileOptions options;
+  UploadExistingFileOptions options;
   std::string etag;
   UploadCompletionCallback callback;
   google_apis::ProgressCallback progress_callback;
 };
 
 // Helper function to work around the arity limitation of base::Bind.
 google_apis::CancelCallback RunUploadExistingFile(
     DriveUploaderInterface* uploader,
     const UploadExistingFileParams& params) {
   return uploader->UploadExistingFile(params.resource_id,
@@ skipping 447 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  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 AddNewDirectoryOptions& options,
     const ClientContext& context,
     const google_apis::FileResourceCallback& callback) {
   DCHECK_CURRENTLY_ON(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,
@@ skipping 42 matching lines @@
   StartJob(new_job);
   return new_job->job_info.job_id;
 }
 
 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 UploadNewFileOptions& options,
     const ClientContext& context,
     const google_apis::FileResourceCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   JobEntry* new_job = CreateNewJob(TYPE_UPLOAD_NEW_FILE);
   new_job->job_info.file_path = drive_file_path;
   new_job->context = context;
 
   GetFileSizeForJob(
       blocking_task_runner_, local_file_path,
@@ skipping 23 matching lines @@
   new_job->task = base::Bind(&RunUploadNewFile, uploader_.get(), params);
   new_job->abort_callback = CreateErrorRunCallback(callback);
   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 UploadExistingFileOptions& options,
     const ClientContext& context,
     const google_apis::FileResourceCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   JobEntry* new_job = CreateNewJob(TYPE_UPLOAD_EXISTING_FILE);
   new_job->job_info.file_path = drive_file_path;
   new_job->context = context;
 
   GetFileSizeForJob(
       blocking_task_runner_, local_file_path,
@@ skipping 517 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