If we read nothing (EOF) after sending a request on a...

net/http/http_network_transaction.cc

 // Copyright (c) 2006-2008 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_network_transaction.h"
 
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
 #include "build/build_config.h"
@@ skipping 558 matching lines @@
   char* buf = header_buf_.get() + header_buf_len_;
   int buf_len = header_buf_capacity_ - header_buf_len_;
 
   return connection_.socket()->Read(buf, buf_len, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
   if (result < 0)
     return HandleIOError(result);
 
+  if (result == 0 && ShouldResendRequest())
+    return result;
+
   // Record our best estimate of the 'response time' as the time when we read
   // the first bytes of the response headers.
   if (header_buf_len_ == 0)
     response_.response_time = Time::Now();
 
   // The socket was closed before we found end-of-headers.
   if (result == 0) {
     if (establishing_tunnel_) {
       // The socket was closed before the tunnel could be established.
       return ERR_TUNNEL_CONNECTION_FAILED;
@@ skipping 252 matching lines @@
 // other cases, such as a Connect error.
 int HttpNetworkTransaction::HandleIOError(int error) {
   switch (error) {
     // If we try to reuse a connection that the server is in the process of
     // closing, we may end up successfully writing out our request (or a
     // portion of our request) only to find a connection error when we try to
     // read from (or finish writing to) the socket.
     case ERR_CONNECTION_RESET:
     case ERR_CONNECTION_CLOSED:
     case ERR_CONNECTION_ABORTED:
-      if (!establishing_tunnel_ &&
-          reused_socket_ &&    // We reused a keep-alive connection.
-          !header_buf_len_) {  // We haven't received any response header yet.
-        connection_.set_socket(NULL);
-        connection_.Reset();
-        request_headers_bytes_sent_ = 0;
-        if (request_body_stream_.get())
-          request_body_stream_->Reset();
-        next_state_ = STATE_INIT_CONNECTION;  // Resend the request.
+      if (ShouldResendRequest())
         error = OK;
-      }
       break;
   }
   return error;
 }
 
+bool HttpNetworkTransaction::ShouldResendRequest() {
+  // NOTE: we resend a request only if we reused a keep-alive connection.
+  // This automatically prevents an infinite resend loop because we'll run
+  // out of the cached keep-alive connections eventually.
+  if (establishing_tunnel_ ||
+      !reused_socket_ ||  // We didn't reuse a keep-alive connection.
+      header_buf_len_) {  // We have received some response headers.
+    return false;
+  }
+  connection_.set_socket(NULL);
+  connection_.Reset();
+  request_headers_bytes_sent_ = 0;
+  if (request_body_stream_.get())
+    request_body_stream_->Reset();
+  next_state_ = STATE_INIT_CONNECTION;  // Resend the request.
+  return true;
+}
+
 }  // namespace net