[HttpStreamParser]: Flush buffers as soon as request is sent.

net/http/http_stream_parser.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 "net/http/http_stream_parser.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 315 matching lines @@
     callback_ = callback;
 
   return result > 0 ? OK : result;
 }
 
 int HttpStreamParser::ReadResponseHeaders(const CompletionCallback& callback) {
   DCHECK(io_state_ == STATE_NONE || io_state_ == STATE_DONE);
   DCHECK(callback_.is_null());
   DCHECK(!callback.is_null());
   DCHECK_EQ(0, read_buf_unused_offset_);
+  DCHECK(SendRequestBuffersEmpty());
 
   // This function can be called with io_state_ == STATE_DONE if the
   // connection is closed after seeing just a 1xx response code.
   if (io_state_ == STATE_DONE)
     return ERR_CONNECTION_CLOSED;
 
   int result = OK;
   io_state_ = STATE_READ_HEADERS;
 
   if (read_buf_->offset() > 0) {
@@ skipping 16 matching lines @@
     connection_->socket()->Disconnect();
   connection_->Reset();
 }
 
 int HttpStreamParser::ReadResponseBody(IOBuffer* buf, int buf_len,
                                        const CompletionCallback& callback) {
   DCHECK(io_state_ == STATE_NONE || io_state_ == STATE_DONE);
   DCHECK(callback_.is_null());
   DCHECK(!callback.is_null());
   DCHECK_LE(buf_len, kMaxBufSize);
+  DCHECK(SendRequestBuffersEmpty());
   // Added to investigate crbug.com/499663.
   CHECK(buf);
 
   if (io_state_ == STATE_DONE)
     return OK;
 
   user_read_buf_ = buf;
   user_read_buf_len_ = buf_len;
   io_state_ = STATE_READ_BODY;
 
@@ skipping 20 matching lines @@
   do {
     DCHECK_NE(ERR_IO_PENDING, result);
     DCHECK_NE(STATE_DONE, io_state_);
     DCHECK_NE(STATE_NONE, io_state_);
     State state = io_state_;
     io_state_ = STATE_NONE;
     switch (state) {
       case STATE_SEND_HEADERS:
         DCHECK_EQ(OK, result);
         result = DoSendHeaders();
+        DCHECK_NE(STATE_NONE, io_state_);
         break;
       case STATE_SEND_HEADERS_COMPLETE:
         result = DoSendHeadersComplete(result);
+        DCHECK_NE(STATE_NONE, io_state_);
         break;
       case STATE_SEND_BODY:
         DCHECK_EQ(OK, result);
         result = DoSendBody();
+        DCHECK_NE(STATE_NONE, io_state_);
         break;
       case STATE_SEND_BODY_COMPLETE:
         result = DoSendBodyComplete(result);
+        DCHECK_NE(STATE_NONE, io_state_);
         break;
       case STATE_SEND_REQUEST_READ_BODY_COMPLETE:
         result = DoSendRequestReadBodyComplete(result);
+        DCHECK_NE(STATE_NONE, io_state_);
+        break;
+      case STATE_SEND_REQUEST_COMPLETE:
+        result = DoSendRequestComplete(result);
         break;
       case STATE_READ_HEADERS:
         net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_PARSER_READ_HEADERS);
         DCHECK_GE(result, 0);
         result = DoReadHeaders();
         break;
       case STATE_READ_HEADERS_COMPLETE:
         result = DoReadHeadersComplete(result);
         net_log_.EndEventWithNetErrorCode(
             NetLog::TYPE_HTTP_STREAM_PARSER_READ_HEADERS, result);
@@ skipping 33 matching lines @@
   return connection_->socket()
       ->Write(request_headers_.get(), bytes_remaining, io_callback_);
 }
 
 int HttpStreamParser::DoSendHeadersComplete(int result) {
   if (result < 0) {
     // In the unlikely case that the headers and body were merged, all the
     // the headers were sent, but not all of the body way, and |result| is
     // an error that this should try reading after, stash the error for now and
     // act like the request was successfully sent.
+    io_state_ = STATE_SEND_REQUEST_COMPLETE;
     if (request_headers_->BytesConsumed() >= request_headers_length_ &&
         ShouldTryReadingOnUploadError(result)) {
       upload_error_ = result;
       return OK;
     }
     return result;
   }
 
   sent_bytes_ += result;
   request_headers_->DidConsume(result);
@@ skipping 11 matching lines @@
         NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_BODY,
         base::Bind(&NetLogSendRequestBodyCallback,
                    request_->upload_data_stream->size(),
                    request_->upload_data_stream->is_chunked(),
                    false /* not merged */));
     io_state_ = STATE_SEND_BODY;
     return OK;
   }
 
   // Finished sending the request.
+  io_state_ = STATE_SEND_REQUEST_COMPLETE;
   return OK;
 }
 
 int HttpStreamParser::DoSendBody() {
   if (request_body_send_buf_->BytesRemaining() > 0) {
     io_state_ = STATE_SEND_BODY_COMPLETE;
     return connection_->socket()
         ->Write(request_body_send_buf_.get(),
                 request_body_send_buf_->BytesRemaining(),
                 io_callback_);
   }
 
   if (request_->upload_data_stream->is_chunked() && sent_last_chunk_) {
     // Finished sending the request.
+    io_state_ = STATE_SEND_REQUEST_COMPLETE;
     return OK;
   }
 
   request_body_read_buf_->Clear();
   io_state_ = STATE_SEND_REQUEST_READ_BODY_COMPLETE;
   return request_->upload_data_stream->Read(request_body_read_buf_.get(),
                                             request_body_read_buf_->capacity(),
                                             io_callback_);
 }
 
 int HttpStreamParser::DoSendBodyComplete(int result) {
   if (result < 0) {
     // If |result| is an error that this should try reading after, stash the
     // error for now and act like the request was successfully sent.
+    io_state_ = STATE_SEND_REQUEST_COMPLETE;
     if (ShouldTryReadingOnUploadError(result)) {
       upload_error_ = result;
       return OK;
     }
     return result;
   }
 
   sent_bytes_ += result;
   request_body_send_buf_->DidConsume(result);
 
   io_state_ = STATE_SEND_BODY;
   return OK;
 }
 
 int HttpStreamParser::DoSendRequestReadBodyComplete(int result) {
   // |result| is the result of read from the request body from the last call to
   // DoSendBody().
-  if (result < 0)
+  if (result < 0) {
+    io_state_ = STATE_SEND_REQUEST_COMPLETE;
     return result;
+  }
 
   // Chunked data needs to be encoded.
   if (request_->upload_data_stream->is_chunked()) {
     if (result == 0) {  // Reached the end.
       DCHECK(request_->upload_data_stream->IsEOF());
       sent_last_chunk_ = true;
     }
     // Encode the buffer as 1 chunk.
     const base::StringPiece payload(request_body_read_buf_->data(), result);
     request_body_send_buf_->Clear();
     result = EncodeChunk(payload,
                          request_body_send_buf_->data(),
                          request_body_send_buf_->capacity());
   }
 
   if (result == 0) {  // Reached the end.
     // Reaching EOF means we can finish sending request body unless the data is
     // chunked. (i.e. No need to send the terminal chunk.)
     DCHECK(request_->upload_data_stream->IsEOF());
     DCHECK(!request_->upload_data_stream->is_chunked());
     // Finished sending the request.
+    io_state_ = STATE_SEND_REQUEST_COMPLETE;
   } else if (result > 0) {
     request_body_send_buf_->DidAppend(result);
     result = 0;
     io_state_ = STATE_SEND_BODY;
   }
   return result;
 }
 
+int HttpStreamParser::DoSendRequestComplete(int result) {
+  DCHECK_NE(result, ERR_IO_PENDING);
+  FlushBuffers();
+  return result;
+}
+
 int HttpStreamParser::DoReadHeaders() {
   io_state_ = STATE_READ_HEADERS_COMPLETE;
 
   // Grow the read buffer if necessary.
   if (read_buf_->RemainingCapacity() == 0)
     read_buf_->SetCapacity(read_buf_->capacity() + kHeaderBufInitialSize);
 
   // http://crbug.com/16371: We're seeing |user_buf_->data()| return NULL.
   // See if the user is passing in an IOBuffer with a NULL |data_|.
   CHECK(read_buf_->data());
@@ skipping 592 matching lines @@
   return false;
 }
 
 void HttpStreamParser::ValidateStatusLine(const std::string& status_line) {
   HttpStatusLineValidator::StatusLineStatus status =
       HttpStatusLineValidator::ValidateStatusLine(status_line);
   UMA_HISTOGRAM_ENUMERATION("Net.HttpStatusLineStatus", status,
                             HttpStatusLineValidator::STATUS_LINE_MAX);
 }
 
+void HttpStreamParser::FlushBuffers() {

[mmenke, 2016/07/12 16:13:41]

nit:  You can inline this in HttpStreamParser::DoSendRequestComplete now.

+  request_headers_ = nullptr;
+  request_body_send_buf_ = nullptr;
+  request_body_read_buf_ = nullptr;
+}
+
+bool HttpStreamParser::SendRequestBuffersEmpty() {
+  return request_headers_ == nullptr && request_body_send_buf_ == nullptr &&
+         request_body_send_buf_ == nullptr;
+}
+
 }  // namespace net