Revert of Revert of Drive: Let DriveUploader use batch request API.

chrome/browser/drive/drive_uploader_unittest.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/drive/drive_uploader.h"
 
+#include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
@@ skipping 27 matching lines @@
 const char kTestDocumentTitle[] = "Hello world";
 const char kTestInitiateUploadParentResourceId[] = "parent_resource_id";
 const char kTestInitiateUploadResourceId[] = "resource_id";
 const char kTestMimeType[] = "text/plain";
 const char kTestUploadNewFileURL[] = "http://test/upload_location/new_file";
 const char kTestUploadExistingFileURL[] =
     "http://test/upload_location/existing_file";
 const int64 kUploadChunkSize = 1024 * 1024 * 1024;
 const char kTestETag[] = "test_etag";
 
+CancelCallback SendMultipartUploadResult(
+    DriveApiErrorCode response_code,
+    int64 content_length,
+    const google_apis::FileResourceCallback& callback,
+    const google_apis::ProgressCallback& progress_callback) {
+  // Callback progress
+  if (!progress_callback.is_null()) {
+    // For the testing purpose, it always notifies the progress at the end of
+    // whole file uploading.
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(progress_callback, content_length, content_length));
+  }
+
+  // MultipartUploadXXXFile is an asynchronous function, so don't callback
+  // directly.
+  scoped_ptr<FileResource> entry;
+  entry.reset(new FileResource);
+  entry->set_md5_checksum(kTestDummyMd5);
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(callback, response_code, base::Passed(&entry)));
+  return CancelCallback();
+}
+
 // Mock DriveService that verifies if the uploaded content matches the preset
 // expectation.
 class MockDriveServiceWithUploadExpectation : public DummyDriveService {
  public:
   // Sets up an expected upload content. InitiateUpload and ResumeUpload will
   // verify that the specified data is correctly uploaded.
   MockDriveServiceWithUploadExpectation(
       const base::FilePath& expected_upload_file,
       int64 expected_content_length)
       : expected_upload_file_(expected_upload_file),
@@ skipping 145 matching lines @@
       const base::FilePath& local_file_path,
       const UploadNewFileOptions& options,
       const google_apis::FileResourceCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override {
     EXPECT_EQ(kTestMimeType, content_type);
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestInitiateUploadParentResourceId, parent_resource_id);
     EXPECT_EQ(kTestDocumentTitle, title);
     EXPECT_EQ(expected_upload_file_, local_file_path);
 
+    received_bytes_ = content_length;
+    multipart_upload_call_count_++;
     return SendMultipartUploadResult(HTTP_CREATED, content_length, callback,
                                      progress_callback);
   }
 
   CancelCallback MultipartUploadExistingFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const base::FilePath& local_file_path,
       const UploadExistingFileOptions& options,
       const google_apis::FileResourceCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override {
     EXPECT_EQ(kTestMimeType, content_type);
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestInitiateUploadResourceId, resource_id);
     EXPECT_EQ(expected_upload_file_, local_file_path);
 
     if (!options.etag.empty() && options.etag != kTestETag) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(callback, HTTP_PRECONDITION,
                      base::Passed(make_scoped_ptr<FileResource>(NULL))));
       return CancelCallback();
     }
 
+    received_bytes_ = content_length;
+    multipart_upload_call_count_++;
     return SendMultipartUploadResult(HTTP_SUCCESS, content_length, callback,
                                      progress_callback);
   }
 
-  CancelCallback SendMultipartUploadResult(
-      DriveApiErrorCode response_code,
-      int64 content_length,
-      const google_apis::FileResourceCallback& callback,
-      const google_apis::ProgressCallback& progress_callback) {
-    received_bytes_ = content_length;
-    multipart_upload_call_count_++;
-
-    // Callback progress
-    if (!progress_callback.is_null()) {
-      // For the testing purpose, it always notifies the progress at the end of
-      // whole file uploading.
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(progress_callback, content_length, content_length));
-    }
-
-    // MultipartUploadXXXFile is an asynchronous function, so don't callback
-    // directly.
-    scoped_ptr<FileResource> entry;
-    entry.reset(new FileResource);
-    entry->set_md5_checksum(kTestDummyMd5);
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(callback, response_code, base::Passed(&entry)));
-    return CancelCallback();
-  }
-
   const base::FilePath expected_upload_file_;
   const int64 expected_content_length_;
   int64 received_bytes_;
   int64 resume_upload_call_count_;
   int64 multipart_upload_call_count_;
 };
 
 // Mock DriveService that returns a failure at InitiateUpload().
 class MockDriveServiceNoConnectionAtInitiate : public DummyDriveService {
   // Returns error.
@@ skipping 472 matching lines @@
   EXPECT_EQ(1024 * 1024, mock_service.received_bytes());
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
   ASSERT_TRUE(entry);
   EXPECT_EQ(kTestDummyMd5, entry->md5_checksum());
   ASSERT_EQ(1U, upload_progress_values.size());
   EXPECT_EQ(test_util::ProgressInfo(1024 * 1024, 1024 * 1024),
             upload_progress_values[0]);
 }
 
+class MockDriveServiceForBatchProcessing : public DummyDriveService {
+ public:
+  struct UploadFileInfo {
+    enum { NEW_FILE, EXISTING_FILE } type;
+    std::string content_type;
+    uint64 content_length;
+    std::string parent_resource_id;
+    std::string resource_id;
+    std::string title;
+    base::FilePath local_file_path;
+    google_apis::FileResourceCallback callback;
+    google_apis::ProgressCallback progress_callback;
+  };
+
+  class BatchRequestConfigurator : public BatchRequestConfiguratorInterface {
+   public:
+    explicit BatchRequestConfigurator(
+        MockDriveServiceForBatchProcessing* service)
+        : service(service) {}
+
+    CancelCallback MultipartUploadNewFile(
+        const std::string& content_type,
+        int64 content_length,
+        const std::string& parent_resource_id,
+        const std::string& title,
+        const base::FilePath& local_file_path,
+        const UploadNewFileOptions& options,
+        const google_apis::FileResourceCallback& callback,
+        const google_apis::ProgressCallback& progress_callback) override {
+      UploadFileInfo info;
+      info.type = UploadFileInfo::NEW_FILE;
+      info.content_type = content_type;
+      info.content_length = content_length;
+      info.parent_resource_id = parent_resource_id;
+      info.title = title;
+      info.local_file_path = local_file_path;
+      info.callback = callback;
+      info.progress_callback = progress_callback;
+      service->files.push_back(info);
+      return CancelCallback();
+    }
+
+    CancelCallback MultipartUploadExistingFile(
+        const std::string& content_type,
+        int64 content_length,
+        const std::string& resource_id,
+        const base::FilePath& local_file_path,
+        const UploadExistingFileOptions& options,
+        const google_apis::FileResourceCallback& callback,
+        const google_apis::ProgressCallback& progress_callback) override {
+      UploadFileInfo info;
+      info.type = UploadFileInfo::EXISTING_FILE;
+      info.content_type = content_type;
+      info.content_length = content_length;
+      info.resource_id = resource_id;
+      info.local_file_path = local_file_path;
+      info.callback = callback;
+      info.progress_callback = progress_callback;
+      service->files.push_back(info);
+      return CancelCallback();
+    }
+
+    void Commit() override {
+      ASSERT_FALSE(service->committed);
+      service->committed = true;
+      for (const auto& file : service->files) {
+        SendMultipartUploadResult(HTTP_SUCCESS, file.content_length,
+                                  file.callback, file.progress_callback);
+      }
+    }
+
+   private:
+    MockDriveServiceForBatchProcessing* service;
+  };
+
+ public:
+  scoped_ptr<BatchRequestConfiguratorInterface> StartBatchRequest() override {
+    committed = false;
+    return scoped_ptr<BatchRequestConfiguratorInterface>(
+        new BatchRequestConfigurator(this));
+  }
+
+  std::vector<UploadFileInfo> files;
+  bool committed;
+};
+
+TEST_F(DriveUploaderTest, BatchProcessing) {
+  // Preapre test file.
+  const size_t kTestFileSize = 1024 * 512;
+  base::FilePath local_path;
+  std::string data;
+  ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
+      temp_dir_.path(), kTestFileSize, &local_path, &data));
+
+  // Prepare test target.
+  MockDriveServiceForBatchProcessing service;
+  DriveUploader uploader(&service, base::ThreadTaskRunnerHandle::Get().get());
+
+  struct {
+    DriveApiErrorCode error;
+    GURL resume_url;
+    scoped_ptr<FileResource> file;
+    UploadCompletionCallback callback() {
+      return test_util::CreateCopyResultCallback(&error, &resume_url, &file);
+    }
+  } results[2];
+
+  uploader.StartBatchProcessing();
+  uploader.UploadNewFile("parent_resource_id", local_path, "title",
+                         kTestMimeType, UploadNewFileOptions(),
+                         results[0].callback(),
+                         google_apis::ProgressCallback());
+  uploader.UploadExistingFile(
+      "resource_id", local_path, kTestMimeType, UploadExistingFileOptions(),
+      results[1].callback(), google_apis::ProgressCallback());
+  uploader.StopBatchProcessing();
+  base::RunLoop().RunUntilIdle();
+
+  ASSERT_EQ(2u, service.files.size());
+  EXPECT_TRUE(service.committed);
+
+  EXPECT_EQ(MockDriveServiceForBatchProcessing::UploadFileInfo::NEW_FILE,
+            service.files[0].type);
+  EXPECT_EQ(kTestMimeType, service.files[0].content_type);
+  EXPECT_EQ(kTestFileSize, service.files[0].content_length);
+  EXPECT_EQ("parent_resource_id", service.files[0].parent_resource_id);
+  EXPECT_EQ("", service.files[0].resource_id);
+  EXPECT_EQ("title", service.files[0].title);
+  EXPECT_EQ(local_path.value(), service.files[0].local_file_path.value());
+
+  EXPECT_EQ(MockDriveServiceForBatchProcessing::UploadFileInfo::EXISTING_FILE,
+            service.files[1].type);
+  EXPECT_EQ(kTestMimeType, service.files[1].content_type);
+  EXPECT_EQ(kTestFileSize, service.files[1].content_length);
+  EXPECT_EQ("", service.files[1].parent_resource_id);
+  EXPECT_EQ("resource_id", service.files[1].resource_id);
+  EXPECT_EQ("", service.files[1].title);
+  EXPECT_EQ(local_path.value(), service.files[1].local_file_path.value());
+
+  EXPECT_EQ(HTTP_SUCCESS, results[0].error);
+  EXPECT_TRUE(results[0].resume_url.is_empty());
+  EXPECT_TRUE(results[0].file);
+
+  EXPECT_EQ(HTTP_SUCCESS, results[1].error);
+  EXPECT_TRUE(results[1].resume_url.is_empty());
+  EXPECT_TRUE(results[1].file);
+}
+
+TEST_F(DriveUploaderTest, BatchProcessingWithError) {
+  // Prepare test target.
+  MockDriveServiceForBatchProcessing service;
+  DriveUploader uploader(&service, base::ThreadTaskRunnerHandle::Get().get());
+
+  struct {
+    DriveApiErrorCode error;
+    GURL resume_url;
+    scoped_ptr<FileResource> file;
+    UploadCompletionCallback callback() {
+      return test_util::CreateCopyResultCallback(&error, &resume_url, &file);
+    }
+  } results[2];
+
+  uploader.StartBatchProcessing();
+  uploader.UploadNewFile("parent_resource_id",
+                         base::FilePath(FILE_PATH_LITERAL("/path/non_exists")),
+                         "title", kTestMimeType, UploadNewFileOptions(),
+                         results[0].callback(),
+                         google_apis::ProgressCallback());
+  uploader.UploadExistingFile(
+      "resource_id", base::FilePath(FILE_PATH_LITERAL("/path/non_exists")),
+      kTestMimeType, UploadExistingFileOptions(), results[1].callback(),
+      google_apis::ProgressCallback());
+  uploader.StopBatchProcessing();
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(0u, service.files.size());
+  EXPECT_TRUE(service.committed);
+
+  EXPECT_EQ(HTTP_NOT_FOUND, results[0].error);
+  EXPECT_TRUE(results[0].resume_url.is_empty());
+  EXPECT_FALSE(results[0].file);
+
+  EXPECT_EQ(HTTP_NOT_FOUND, results[1].error);
+  EXPECT_TRUE(results[1].resume_url.is_empty());
+  EXPECT_FALSE(results[1].file);
+}
 }  // namespace drive