Drive: Let DriveUploader use batch request API.

chrome/browser/drive/drive_uploader.h

 // 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.
 
 #ifndef CHROME_BROWSER_DRIVE_DRIVE_UPLOADER_H_
 #define CHROME_BROWSER_DRIVE_DRIVE_UPLOADER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 25 matching lines @@
 typedef base::Callback<void(
     google_apis::DriveApiErrorCode error,
     const GURL& upload_location,
     scoped_ptr<google_apis::FileResource> resource_entry)>
     UploadCompletionCallback;
 
 class DriveUploaderInterface {
  public:
   virtual ~DriveUploaderInterface() {}
 
+  // Starts batch processing for upload requests. All requests which upload
+  // small files (less than kMaxMultipartUploadSize) between
+  // |StartBatchProcessing| and |StopBatchProcessing| are sent as a single batch
+  // request.
+  virtual void StartBatchProcessing() = 0;
+
+  // Stops batch processing. Must be called after calling |StartBatchProcessing|
+  // to commit requests.
+  virtual void StopBatchProcessing() = 0;
+
   // Uploads a new file to a directory specified by |upload_location|.
   // Returns a callback for cancelling the uploading job.
   //
   // parent_resource_id:
   //   resource id of the destination directory.
   //
   // local_file_path:
   //   The path to the local file to be uploaded.
   //
   // title:
@@ skipping 51 matching lines @@
       const google_apis::ProgressCallback& progress_callback) = 0;
 };
 
 class DriveUploader : public DriveUploaderInterface {
  public:
   DriveUploader(DriveServiceInterface* drive_service,
                 const scoped_refptr<base::TaskRunner>& blocking_task_runner);
   ~DriveUploader() override;
 
   // DriveUploaderInterface overrides.
+  void StartBatchProcessing() override;
+  void StopBatchProcessing() override;
   google_apis::CancelCallback UploadNewFile(
       const std::string& parent_resource_id,
       const base::FilePath& local_file_path,
       const std::string& title,
       const std::string& content_type,
       const UploadNewFileOptions& options,
       const UploadCompletionCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override;
   google_apis::CancelCallback UploadExistingFile(
       const std::string& resource_id,
       const base::FilePath& local_file_path,
       const std::string& content_type,
       const UploadExistingFileOptions& options,
       const UploadCompletionCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override;
   google_apis::CancelCallback ResumeUploadFile(
       const GURL& upload_location,
       const base::FilePath& local_file_path,
       const std::string& content_type,
       const UploadCompletionCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override;
 
  private:
+  class RefCountedBatchRequest;
   struct UploadFileInfo;
   typedef base::Callback<void(scoped_ptr<UploadFileInfo> upload_file_info)>
       StartInitiateUploadCallback;
 
   // Starts uploading a file with |upload_file_info|.
   google_apis::CancelCallback StartUploadFile(
       scoped_ptr<UploadFileInfo> upload_file_info,
       const StartInitiateUploadCallback& start_initiate_upload_callback);
   void StartUploadFileAfterGetFileSize(
       scoped_ptr<UploadFileInfo> upload_file_info,
       const StartInitiateUploadCallback& start_initiate_upload_callback,
       bool get_file_size_result);
 
   // Checks file size and call InitiateUploadNewFile or MultipartUploadNewFile
   // API.  Upon completion, OnUploadLocationReceived (for InitiateUploadNewFile)
   // or OnMultipartUploadComplete (for MultipartUploadNewFile) should be called.
-  void CallUploadServiceAPINewFile(const std::string& parent_resource_id,
-                                   const std::string& title,
-                                   const UploadNewFileOptions& options,
-                                   scoped_ptr<UploadFileInfo> upload_file_info);
+  // If |batch_request| is non-null, it calls the API function on the batch
+  // request.
+  void CallUploadServiceAPINewFile(
+      const std::string& parent_resource_id,
+      const std::string& title,
+      const UploadNewFileOptions& options,
+      const scoped_refptr<RefCountedBatchRequest>& batch_request,
+      scoped_ptr<UploadFileInfo> upload_file_info);
 
   // Checks file size and call InitiateUploadExistingFile or
   // MultipartUploadExistingFile API.  Upon completion, OnUploadLocationReceived
   // (for InitiateUploadExistingFile) or OnMultipartUploadComplete (for
   // MultipartUploadExistingFile) should be called.
+  // If |batch_request| is non-null, it calls the API function on the batch
+  // request.
   void CallUploadServiceAPIExistingFile(
       const std::string& resource_id,
       const UploadExistingFileOptions& options,
+      const scoped_refptr<RefCountedBatchRequest>& batch_request,
       scoped_ptr<UploadFileInfo> upload_file_info);
 
   // DriveService callback for InitiateUpload.
   void OnUploadLocationReceived(scoped_ptr<UploadFileInfo> upload_file_info,
                                 google_apis::DriveApiErrorCode code,
                                 const GURL& upload_location);
 
   // Starts to get the current upload status for the file uploading.
   // Upon completion, OnUploadRangeResponseReceived should be called.
   void StartGetUploadStatus(scoped_ptr<UploadFileInfo> upload_file_info);
@@ skipping 22 matching lines @@
                                  scoped_ptr<google_apis::FileResource> entry);
 
   // The class is expected to run on UI thread.
   base::ThreadChecker thread_checker_;
 
   // The lifetime of this object should be guaranteed to exceed that of the
   // DriveUploader instance.
   DriveServiceInterface* drive_service_;  // Not owned by this class.
 
   scoped_refptr<base::TaskRunner> blocking_task_runner_;
+  scoped_refptr<RefCountedBatchRequest> current_batch_request_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<DriveUploader> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DriveUploader);
 };
 
 }  // namespace drive
 
 #endif  // CHROME_BROWSER_DRIVE_DRIVE_UPLOADER_H_