Notify upload progress from batch request to its child requests.

google_apis/drive/drive_api_requests_unittest.cc

 // Copyright (c) 2013 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 "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 69 matching lines @@
   }
   net::URLFetcher::RequestType GetRequestType() const override {
     return net::URLFetcher::PUT;
   }
   bool GetContentData(std::string* upload_content_type,
                       std::string* upload_content) override {
     upload_content_type->assign(content_type_);
     upload_content->assign(content_data_);
     return true;
   }
+  void OnURLFetchUploadProgress(const net::URLFetcher* source,
+                                int64 current,
+                                int64 total) override {
+    progress_values_.push_back(current);
+  }
+  const std::vector<int64>& progress_values() const { return progress_values_; }
 
  private:
   GURL url_;
   std::string content_type_;
   std::string content_data_;
   base::Closure callback_;
+  std::vector<int64> progress_values_;
 };
 
 }  // namespace
 
 class DriveApiRequestsTest : public testing::Test {
  public:
   DriveApiRequestsTest() {
   }
 
   void SetUp() override {
@@ skipping 1959 matching lines @@
   drive::BatchUploadRequest* const request =
       new drive::BatchUploadRequest(request_sender_.get(), *url_generator_);
   request->SetBoundaryForTesting("OUTERBOUNDARY");
   request_sender_->StartRequestWithRetry(request);
 
   // Create child request.
   {
     base::RunLoop loop;
     TestBatchableRequest* child_request = new TestBatchableRequest(
         request_sender_.get(), GURL("http://example.com/test"),
-        "application/binary",
-        std::string("Apple\0Orange\0", 13),
+        "application/binary", std::string("Apple\0Orange\0", 13),
         loop.QuitClosure());
     request->AddRequest(child_request);
     request->Commit();
     loop.Run();
   }
 
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("batch", http_request_.headers["X-Goog-Upload-Protocol"]);
   EXPECT_EQ("multipart/mixed; boundary=OUTERBOUNDARY",
             http_request_.headers["Content-Type"]);
   EXPECT_EQ(
       "--OUTERBOUNDARY\n"
       "Content-Type: application/http\n"
       "\n"
       "PUT /test HTTP/1.1\n"
       "Host: 127.0.0.1\n"
       "X-Goog-Upload-Protocol: multipart\n"
       "Content-Type: application/binary\n"
-      "\n"
-      + std::string("Apple\0Orange\0", 13) + "\n"
-      "--OUTERBOUNDARY--",
+      "\n" +
+          std::string("Apple\0Orange\0", 13) +
+          "\n"
+          "--OUTERBOUNDARY--",
       http_request_.content);
 }
 
+void EmptyPreapreCallback(DriveApiErrorCode) {
+}
+
+TEST_F(DriveApiRequestsTest, BatchUploadRequestProgress) {
+  // Create batch request.
+  drive::BatchUploadRequest* const request =
+      new drive::BatchUploadRequest(request_sender_.get(), *url_generator_);
+  TestBatchableRequest* requests[] = {
+      new TestBatchableRequest(
+          request_sender_.get(), GURL("http://example.com/test"),
+          "application/binary", std::string(100, 'a'), base::Closure()),
+      new TestBatchableRequest(
+          request_sender_.get(), GURL("http://example.com/test"),
+          "application/binary", std::string(50, 'b'), base::Closure()),
+      new TestBatchableRequest(
+          request_sender_.get(), GURL("http://example.com/test"),
+          "application/binary", std::string(0, 'c'), base::Closure())};
+  const size_t kExpectedUploadDataPosition[] = {208, 517, 776};
+  const size_t kExpectedUploadDataSize = 851;
+  request->AddRequest(requests[0]);
+  request->AddRequest(requests[1]);
+  request->AddRequest(requests[2]);
+  request->Commit();
+  request->Prepare(base::Bind(&EmptyPreapreCallback));
+
+  request->OnURLFetchUploadProgress(nullptr, 0, kExpectedUploadDataSize);
+  request->OnURLFetchUploadProgress(nullptr, 150, kExpectedUploadDataSize);
+  EXPECT_EQ(0u, requests[0]->progress_values().size());
+  EXPECT_EQ(0u, requests[1]->progress_values().size());
+  EXPECT_EQ(0u, requests[2]->progress_values().size());
+  request->OnURLFetchUploadProgress(nullptr, kExpectedUploadDataPosition[0],
+                                    kExpectedUploadDataSize);
+  EXPECT_EQ(1u, requests[0]->progress_values().size());
+  EXPECT_EQ(0u, requests[1]->progress_values().size());
+  EXPECT_EQ(0u, requests[2]->progress_values().size());
+  request->OnURLFetchUploadProgress(
+      nullptr, kExpectedUploadDataPosition[0] + 50, kExpectedUploadDataSize);
+  EXPECT_EQ(2u, requests[0]->progress_values().size());
+  EXPECT_EQ(0u, requests[1]->progress_values().size());
+  EXPECT_EQ(0u, requests[2]->progress_values().size());
+  request->OnURLFetchUploadProgress(
+      nullptr, kExpectedUploadDataPosition[1] + 20, kExpectedUploadDataSize);
+  EXPECT_EQ(3u, requests[0]->progress_values().size());
+  EXPECT_EQ(1u, requests[1]->progress_values().size());
+  EXPECT_EQ(0u, requests[2]->progress_values().size());
+  request->OnURLFetchUploadProgress(nullptr, kExpectedUploadDataPosition[2],
+                                    kExpectedUploadDataSize);
+  EXPECT_EQ(3u, requests[0]->progress_values().size());
+  EXPECT_EQ(2u, requests[1]->progress_values().size());
+  EXPECT_EQ(1u, requests[2]->progress_values().size());
+  request->OnURLFetchUploadProgress(nullptr, kExpectedUploadDataSize,
+                                    kExpectedUploadDataSize);
+  ASSERT_EQ(3u, requests[0]->progress_values().size());
+  EXPECT_EQ(0, requests[0]->progress_values()[0]);
+  EXPECT_EQ(50, requests[0]->progress_values()[1]);
+  EXPECT_EQ(100, requests[0]->progress_values()[2]);
+  ASSERT_EQ(2u, requests[1]->progress_values().size());
+  EXPECT_EQ(20, requests[1]->progress_values()[0]);
+  EXPECT_EQ(50, requests[1]->progress_values()[1]);
+  ASSERT_EQ(1u, requests[2]->progress_values().size());
+  EXPECT_EQ(0, requests[2]->progress_values()[0]);
+}
+
 TEST(ParseMultipartResponseTest, Empty) {
   std::vector<drive::MultipartHttpResponse> parts;
   EXPECT_FALSE(drive::ParseMultipartResponse(
       "multipart/mixed; boundary=BOUNDARY", "", &parts));
   EXPECT_FALSE(drive::ParseMultipartResponse("multipart/mixed; boundary=",
                                              "CONTENT", &parts));
 }
 
 TEST(ParseMultipartResponseTest, Basic) {
   std::vector<drive::MultipartHttpResponse> parts;
@@ skipping 88 matching lines @@
                                     "Header: value\r\n"
                                     "\r\n"
                                     "BODY\r\n"
                                     "--BOUNDARY-- \t",
                                     &parts));
   ASSERT_EQ(1u, parts.size());
   EXPECT_EQ(HTTP_SUCCESS, parts[0].code);
   EXPECT_EQ("BODY", parts[0].body);
 }
 }  // namespace google_apis