Prototype of chunked transfer encoded POST.

net/http/http_stream_parser.cc

 // Copyright (c) 2010 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/http/http_stream_parser.h"
 
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "net/base/auth.h"
 #include "net/base/io_buffer.h"
@@ skipping 49 matching lines @@
         NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
         make_scoped_refptr(new NetLogHttpRequestParameter(
             request_line, headers)));
   }
   response_ = response;
   std::string request = request_line + headers.ToString();
   scoped_refptr<StringIOBuffer> headers_io_buf(new StringIOBuffer(request));
   request_headers_ = new DrainableIOBuffer(headers_io_buf,
                                            headers_io_buf->size());
   request_body_.reset(request_body);
+  if (request_body_.get() && request_body_->is_chunked())

[wtc, 2011/01/20 00:29:47]

Nit: request_body_.get() => request_body_ != NULL
to match existing code (see lines 227 and 250 below).

+    request_body_->set_chunk_callback(this);
 
   io_state_ = STATE_SENDING_HEADERS;
   int result = DoLoop(OK);
   if (result == ERR_IO_PENDING)
     user_callback_ = callback;
 
   return result > 0 ? OK : result;
 }
 
 int HttpStreamParser::ReadResponseHeaders(CompletionCallback* callback) {
@@ skipping 56 matching lines @@
 
   // The client callback can do anything, including destroying this class,
   // so any pending callback must be issued after everything else is done.
   if (result != ERR_IO_PENDING && user_callback_) {
     CompletionCallback* c = user_callback_;
     user_callback_ = NULL;
     c->Run(result);
   }
 }
 
+void HttpStreamParser::OnChunkAvailable() {
+  // This method may get called in any state so check before processing the new

[wtc, 2011/01/20 00:29:47]

If you add the DCHECK vandebo suggested, please update
"in any state" in this comment to match the DCHECK.

+  // data. If we were still initializing or sending headers, we will
+  // automatically start reading the chunks once we get into STATE_SENDING_BODY
+  // so nothing to do here.

[vandebo (ex-Chrome), 2011/01/18 21:51:17]

nit:  You could DCHECK(io_state_ == STATE_SENDING_HEADERS || io_state_ ==
STATE_SENDING_BODY)

+  if (io_state_ == STATE_SENDING_BODY)
+    OnIOComplete(0);
+}
+
 int HttpStreamParser::DoLoop(int result) {
   bool can_do_more = true;
   do {
     switch (io_state_) {
       case STATE_SENDING_HEADERS:
         if (result < 0)
           can_do_more = false;
         else
           result = DoSendHeaders(result);
         break;
@@ skipping 46 matching lines @@
   if (bytes_remaining > 0) {
     // Record our best estimate of the 'request time' as the time when we send
     // out the first bytes of the request headers.
     if (bytes_remaining == request_headers_->size()) {
       response_->request_time = base::Time::Now();
 
       // We'll record the count of uncoalesced packets IFF coalescing will help,
       // and otherwise we'll use an enum to tell why it won't help.
       enum COALESCE_POTENTIAL {
         NO_ADVANTAGE = 0,   // Coalescing won't reduce packet count.
         HEADER_ONLY = 1,    // There is only a header packet (can't coalesce).

[wtc, 2011/01/20 00:29:47]

In light of your change to line 227, the HEADER_ONLY enum
should also be documented to include the chunked encoding
case, which has a request body but the request body isn't
available yet.

         COALESCE_POTENTIAL_MAX = 30 // Various cases of coalasced savings.
       };
       size_t coalesce = HEADER_ONLY;
-      if (request_body_ != NULL) {
+      if (request_body_ != NULL && !request_body_->is_chunked()) {
         const size_t kBytesPerPacket = 1430;
         uint64 body_packets = (request_body_->size() + kBytesPerPacket - 1) /
                               kBytesPerPacket;
         uint64 header_packets = (bytes_remaining + kBytesPerPacket - 1) /
                                 kBytesPerPacket;
         uint64 coalesced_packets = (request_body_->size() + bytes_remaining +
                                     kBytesPerPacket - 1) / kBytesPerPacket;
         if (coalesced_packets < header_packets + body_packets) {
           if (coalesced_packets > COALESCE_POTENTIAL_MAX)
             coalesce = COALESCE_POTENTIAL_MAX;
           else
             coalesce = static_cast<size_t>(header_packets + body_packets);
         } else {
           coalesce = NO_ADVANTAGE;
         }
       }
       UMA_HISTOGRAM_ENUMERATION("Net.CoalescePotential", coalesce,
                                 COALESCE_POTENTIAL_MAX);
     }
     result = connection_->socket()->Write(request_headers_,
                                           bytes_remaining,
                                           &io_callback_);
-  } else if (request_body_ != NULL && request_body_->size()) {
+  } else if (request_body_ != NULL &&
+             (request_body_->is_chunked() || request_body_->size())) {
     io_state_ = STATE_SENDING_BODY;
     result = OK;
   } else {
     io_state_ = STATE_REQUEST_SENT;
   }
   return result;
 }
 
 int HttpStreamParser::DoSendBody(int result) {
   if (result > 0)
     request_body_->DidConsume(result);
 
   if (!request_body_->eof()) {
     int buf_len = static_cast<int>(request_body_->buf_len());
-    result = connection_->socket()->Write(request_body_->buf(), buf_len,
-                                          &io_callback_);
+    if (buf_len) {
+      result = connection_->socket()->Write(request_body_->buf(), buf_len,
+                                            &io_callback_);
+    } else {
+      // More POST data is to come hence wait for the callback.
+      result = ERR_IO_PENDING;
+    }
   } else {
     io_state_ = STATE_REQUEST_SENT;
   }
   return result;
 }
 
 int HttpStreamParser::DoReadHeaders() {
   io_state_ = STATE_READ_HEADERS_COMPLETE;
 
   // Grow the read buffer if necessary.
@@ skipping 364 matching lines @@
 void HttpStreamParser::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   if (request_->url.SchemeIs("https") && connection_->socket()) {
     SSLClientSocket* ssl_socket =
         static_cast<SSLClientSocket*>(connection_->socket());
     ssl_socket->GetSSLCertRequestInfo(cert_request_info);
   }
 }
 
 }  // namespace net