Treat ERR_CONNECTION_CLOSED as end-of-data marker for downloads.

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 "base/string_util.h"
 #include "net/base/address_list.h"
 #include "net/base/auth.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/http/http_net_log_params.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/client_socket_handle.h"
 
+static std::string GetResponseHeaderLines(

[rvargas (doing something else), 2011/05/19 19:30:36]

nit: can you use an anonymous namespace instead?

[ahendrickson, 2011/05/19 22:29:34]

Done.

+    const net::HttpResponseHeaders& headers) {
+  std::string raw_headers = headers.raw_headers();
+  const char* null_separated_headers = raw_headers.c_str();
+  const char* header_line = null_separated_headers;
+  std::string cr_separated_headers;
+  while (header_line[0] != 0) {
+    cr_separated_headers += header_line;
+    cr_separated_headers += "\n";
+    header_line += strlen(header_line) + 1;

[rvargas (doing something else), 2011/05/19 19:30:36]

It probably doesn't matter too much, but it looks like you are going twice over
header_line looking for nulls, and building a temp string anyway. I'd leave less
work for the optimizer.

+  }
+  return cr_separated_headers;
+}
+
 namespace net {
 
 HttpStreamParser::HttpStreamParser(ClientSocketHandle* connection,
                                    const HttpRequestInfo* request,
                                    GrowableIOBuffer* read_buffer,
                                    const BoundNetLog& net_log)
     : io_state_(STATE_NONE),
       request_(request),
       request_headers_(NULL),
       request_body_(NULL),
@@ skipping 30 matching lines @@
   DCHECK(!user_callback_);
   DCHECK(callback);
   DCHECK(response);
 
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.AddEvent(
         NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
         make_scoped_refptr(new NetLogHttpRequestParameter(
             request_line, headers)));
   }
+  VLOG(20) << __FUNCTION__ << "()"

[rvargas (doing something else), 2011/05/19 19:30:36]

This looks odd. Could you use DVLOG instead?. Having random numbers like 20
makes it pretty hard to know what to look for unless one finds this line in the
code first. Also, this is pretty much the same thing that goes to the
net_internals log, and there is a command line option to direct the
net_internals log to the regular log output.

[ahendrickson, 2011/05/19 22:29:34]

Switched to DVLOG.

20 is the number we use for debugging downloads.  We figured it wouldn't
interfere with others' debugging $-).

I did not know about the command-line option (log-net-log).  Just tried it, and
it has a LOT of output, so it's harder for me to read and not as helpful as this
code.

+           << " request_line = \"" << request_line << "\""
+           << " headers = \"" << headers.ToString() << "\"";
   response_ = response;
 
   // Put the peer's IP address and port into the response.
   AddressList address;
   int result = connection_->socket()->GetPeerAddress(&address);
   if (result != OK)
     return result;
   response_->socket_address = HostPortPair::FromAddrInfo(address.head());
 
   std::string request = request_line + headers.ToString();
@@ skipping 530 matching lines @@
     std::string content_length_value2;
     while (headers->EnumerateHeader(
         &it, content_length_header, &content_length_value2)) {
       if (content_length_value != content_length_value2)
         return ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH;
     }
   }
 
   response_->headers = headers;
   response_->vary_data.Init(*request_, *response_->headers);
+  VLOG(20) << __FUNCTION__ << "()"

[rvargas (doing something else), 2011/05/19 19:30:36]

same here (and other places)

[ahendrickson, 2011/05/19 22:29:34]

Done.

+           << " content_length = \""
+           << response_->headers->GetContentLength() << "\n\""
+           << " headers = \"" << GetResponseHeaderLines(*response_->headers)
+           << "\"";
   return OK;
 }
 
 void HttpStreamParser::CalculateResponseBodySize() {
   // Figure how to determine EOF:
 
   // For certain responses, we know the content length is always 0. From
   // RFC 2616 Section 4.3 Message Body:
   //
   // For response messages, whether or not a message-body is included with
@@ skipping 79 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