Prototype of chunked transfer encoded POST.

net/url_request/url_request_unittest.cc

 // Copyright (c) 2011 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 "net/url_request/url_request_unittest.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <shlobj.h>
@@ skipping 620 matching lines @@
     ASSERT_EQ(1, d.response_started_count()) << "request failed: " <<
         (int) r.status().status() << ", os error: " << r.status().os_error();
 
     EXPECT_FALSE(d.received_data_before_response());
 
     ASSERT_EQ(size, d.bytes_received());
     EXPECT_EQ(0, memcmp(d.data_received().c_str(), buf.get(), size));
   }
 }
 
+TEST_F(URLRequestTestHTTP, PostChunkedDataTest) {

[vandebo (ex-Chrome), 2011/01/21 18:08:41]

If I read this test right, it looks like all the data will be queued before
HttpStreamParser tries to access any of it.  It would also be good to have a
test where HttpStreamParser will exercise the ERR_IO_PENDING during upload case.

[Satish, 2011/01/21 20:29:57]

Makes sense. I could do that in this same test by posting a task before calling
r.Start() and in that task function add 2 of these chunks. That should allow
URLRequest to process the existing chunks and return to the message loop before
handling the last 2 chunks. Is that ok?

+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  {
+    TestURLRequest r(test_server_.GetURL("echo"), &d);
+    r.EnableChunkedUpload();
+    r.set_method("POST");
+    r.AppendChunkToUpload("a", 1);

[vandebo (ex-Chrome), 2011/01/21 18:08:41]

I thought you weren't supposed to call AppendChunkToUpload before starting the
request.

[Satish, 2011/01/21 20:29:57]

Good catch, yes the code is allowing these calls before Start.. the condition is
that EnableChunkedUpload should have been called. I'll update the comment in
URLRequest to mention this.

[vandebo (ex-Chrome), 2011/01/21 20:47:13]

Having two tests would yield better test coverage.  One with all the chunks
there before HttpStreamParser first looks, and another with none there.  That
would test both cases of the ERR_IO_PENDING mechanism as well as the base
case/exception of the EOF logic.

+    r.AppendChunkToUpload("bcd", 3);
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    r.AppendChunkToUpload("this is a longer chunk than before.", 35);
+    r.AppendChunkToUpload("\r\n\r\n", 4);
+    r.AppendChunkToUpload("0", 1);
+    r.AppendChunkToUpload("2323", 4);
+    r.MarkEndOfChunks();
+
+    MessageLoop::current()->Run();
+
+    const char* encoded_data =
+        "abcdthis is a longer chunk than before.\r\n\r\n02323";
+
+    ASSERT_EQ(1, d.response_started_count()) << "request failed: " <<
+        (int) r.status().status() << ", os error: " << r.status().os_error();
+
+    EXPECT_FALSE(d.received_data_before_response());
+
+    ASSERT_EQ(strlen(encoded_data), static_cast<size_t>(d.bytes_received()));
+    EXPECT_EQ(0, memcmp(d.data_received().c_str(), encoded_data,
+                        strlen(encoded_data)));
+  }
+}
+
 TEST_F(URLRequestTest, AboutBlankTest) {
   TestDelegate d;
   {
     TestURLRequest r(GURL("about:blank"), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
@@ skipping 2013 matching lines @@
   TestURLRequest
       req(test_server_.GetURL("echoheaderoverride?User-Agent"), &d);
   req.set_context(new TestURLRequestContext());
   net::HttpRequestHeaders headers;
   headers.SetHeader(net::HttpRequestHeaders::kUserAgent, "Lynx (textmode)");
   req.SetExtraRequestHeaders(headers);
   req.Start();
   MessageLoop::current()->Run();
   EXPECT_EQ(std::string("Lynx (textmode)"), d.data_received());
 }