Fix issues with GenericURLRequestJob and multiple elements

Bug: 
Change-Id: Iac5361077c24160af5a73a42f5bdd4e74309cf16
Reviewed-on: https://chromium-review.googlesource.com/796671Reviewed-by: Eric Seckler <eseckler@chromium.org>
Commit-Queue: Alex Clarke <alexclarke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#520127}

headless/public/util/generic_url_request_job.cc

@@ -333,10 +333,10 @@ bool ReadAndAppendBytes(const std::unique_ptr<net::UploadElementReader>& reader,
   }
 
   // Read the POST bytes.
-  uint64_t content_length = reader->GetContentLength();
+  uint64_t size_to_stop_at = post_data.size() + reader->GetContentLength();
   const size_t block_size = 1024;
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(block_size));
-  while (post_data.size() < content_length) {
+  while (post_data.size() < size_to_stop_at) {
     base::Closure quit_closure;
     int bytes_read = reader->Read(
         read_buffer.get(), block_size,
@@ -409,10 +409,17 @@ uint64_t GenericURLRequestJob::GetPostDataSize() const {
   if (stream->GetElementReaders()->size() == 0)
     return 0;
 
-  DCHECK_EQ(1u, stream->GetElementReaders()->size());
-  const std::unique_ptr<net::UploadElementReader>& reader =
-      (*stream->GetElementReaders())[0];
-  return reader->GetContentLength();
+  const std::vector<std::unique_ptr<net::UploadElementReader>>* readers =
+      stream->GetElementReaders();
+  if (!readers)
+    return 0;
+
+  uint64_t total_content_length = 0;
+  for (size_t i = 0; i < readers->size(); ++i) {
+    const std::unique_ptr<net::UploadElementReader>& reader = (*readers)[i];
+    total_content_length += reader->GetContentLength();
+  }
+  return total_content_length;
 }
 
 }  // namespace headless

headless/public/util/generic_url_request_job_test.cc

@@ -58,12 +58,12 @@ class MockDelegate : public MockGenericURLRequestJobDelegate {
 class MockFetcher : public URLFetcher {
  public:
   MockFetcher(base::DictionaryValue* fetch_request,
-              std::string* recieved_post_data,
+              std::string* received_post_data,
               std::map<std::string, std::string>* json_fetch_reply_map,
               base::Callback<void(const Request*)>* on_request_callback)
       : json_fetch_reply_map_(json_fetch_reply_map),
         fetch_request_(fetch_request),
-        received_post_data_(recieved_post_data),
+        received_post_data_(received_post_data),
         on_request_callback_(on_request_callback) {}
 
   ~MockFetcher() override = default;
@@ -139,13 +139,13 @@ class MockProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler {
   // Details of the fetch will be stored in |fetch_request|.
   // The fetch response will be created from parsing |json_fetch_reply_map|.
   MockProtocolHandler(base::DictionaryValue* fetch_request,
-                      std::string* recieved_post_data,
+                      std::string* received_post_data,
                       std::map<std::string, std::string>* json_fetch_reply_map,
                       URLRequestDispatcher* dispatcher,
                       GenericURLRequestJob::Delegate* job_delegate,
                       base::Callback<void(const Request*)>* on_request_callback)
       : fetch_request_(fetch_request),
-        received_post_data_(recieved_post_data),
+        received_post_data_(received_post_data),
         json_fetch_reply_map_(json_fetch_reply_map),
         job_delegate_(job_delegate),
         dispatcher_(dispatcher),
@@ -694,7 +694,6 @@ TEST_F(GenericURLRequestJobTest, LargePostDataNotByteReader) {
   for (size_t i = 0; i < post_data.size(); i++)
     post_data.at(i) = i & 127;
 
-  // TODO(alexclarke) Add a multiple element test too.
   request->set_upload(net::ElementsUploadDataStream::CreateWithReader(
       base::MakeUnique<ByteAtATimeUploadElementReader>(post_data), 0));
   request->Start();
@@ -708,4 +707,39 @@ TEST_F(GenericURLRequestJobTest, LargePostDataNotByteReader) {
   EXPECT_EQ(post_data.size(), received_post_data_.size());
 }
 
+TEST_F(GenericURLRequestJobTest, PostWithMultipleElements) {
+  json_fetch_reply_map_["https://example.com/"] = R"(
+      {
+        "url": "https://example.com",
+        "data": "Reply",
+        "headers": {
+          "Content-Type": "text/html; charset=UTF-8"
+        }
+      })";
+
+  std::unique_ptr<net::URLRequest> request(url_request_context_.CreateRequest(
+      GURL("https://example.com"), net::DEFAULT_PRIORITY, &request_delegate_,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
+  request->SetReferrer("https://referrer.example.com");
+  request->SetExtraRequestHeaderByName("Extra-Header", "Value", true);
+  request->SetExtraRequestHeaderByName("User-Agent", "TestBrowser", true);
+  request->SetExtraRequestHeaderByName("Accept", "text/plain", true);
+  request->set_method("POST");
+
+  std::vector<std::unique_ptr<net::UploadElementReader>> element_readers;
+  element_readers.push_back(
+      base::MakeUnique<ByteAtATimeUploadElementReader>("Does "));
+  element_readers.push_back(
+      base::MakeUnique<ByteAtATimeUploadElementReader>("this "));
+  element_readers.push_back(
+      base::MakeUnique<ByteAtATimeUploadElementReader>("work?"));
+
+  request->set_upload(base::MakeUnique<net::ElementsUploadDataStream>(
+      std::move(element_readers), 0));
+  request->Start();
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ("Does this work?", received_post_data_);
+}
+
 }  // namespace headless