Ignore Content-Length mismatches when Content-Length is too large.

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 "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "net/base/address_list.h"
@@ skipping 644 matching lines @@
   // Check to see if we're done reading.
   if (IsResponseBodyComplete())
     return 0;
 
   DCHECK_EQ(0, read_buf_->offset());
   return connection_->socket()->Read(user_read_buf_, user_read_buf_len_,
                                      io_callback_);
 }
 
 int HttpStreamParser::DoReadBodyComplete(int result) {
-  // If we didn't get a Content-Length and aren't using a chunked encoding,
-  // the only way to signal the end of a stream is to close the connection,
-  // so we don't treat that as an error, though in some cases we may not
-  // have completely received the resource.
-  if (result == 0 && !IsResponseBodyComplete() && CanFindEndOfResponse())
-    result = ERR_CONNECTION_CLOSED;
+  // When the connection is closed, there are numerous ways to interpret it.
+  //
+  //  - If a Content-Length header is present and the body contains exactly that
+  //    number of bytes at connection close, the response is successful.
+  //
+  //  - If a Content-Length header is present and the body contains fewer bytes
+  //    than promised by the header at connection close, it may indicate that
+  //    the connection was closed prematurely, or it may indicate that the
+  //    server sent an invalid Content-Length header. Unfortunately, the invalid
+  //    Content-Length header case does occur in practice and other browsers are
+  //    tolerant of it, so this is reported as OK.
+  //
+  //  - If chunked encoding is used and the terminating chunk has been processed
+  //    when the connection is closed, the response is successful.
+  //
+  //  - If chunked encoding is used and the terminating chunk has not been
+  //    processed when the connection is closed, it may indicate that the
+  //    connection was closed prematurely or it may indicate that the server
+  //    sent an invalid chunked encoding. We choose to treat it as
+  //    an invalid chunked encoding.
+  //
+  //  - If a Content-Length is not present and chunked encoding is not used,
+  //    connection close is the only way to signal that the response is
+  //    complete. Unfortunately, this also means that there is no way to detect
+  //    early close of a connection. No error is returned.
+  if (result == 0 && !IsResponseBodyComplete() && CanFindEndOfResponse()) {
+    if (chunked_decoder_.get())
+      result = ERR_INVALID_CHUNKED_ENCODING;
+    else
+      result = ERR_CONNECTION_CLOSED;

[rvargas (doing something else), 2012/03/23 20:50:29]

So we still return an error code at this layer in any case (contrary to the
comment)... and now there's not "fixup" for content length at the job layer...
so we're back to always fail.

[cbentzel, 2012/03/23 21:19:20]

Oops, this was a bad local patch that I did to make sure that the tests failed
when it was not returning OK. 

+  }
 
   // Filter incoming data if appropriate.  FilterBuf may return an error.
   if (result > 0 && chunked_decoder_.get()) {
     result = chunked_decoder_->FilterBuf(user_read_buf_->data(), result);
     if (result == 0 && !chunked_decoder_->reached_eof()) {
       // Don't signal completion of the Read call yet or else it'll look like
       // we received end-of-file.  Wait for more data.
       io_state_ = STATE_READ_BODY;
       return OK;
     }
@@ skipping 243 matching lines @@
       request_body->IsInMemory() &&
       request_body->size() > 0) {
     size_t merged_size = request_headers.size() + request_body->size();
     if (merged_size <= kMaxMergedHeaderAndBodySize)
       return true;
   }
   return false;
 }
 
 }  // namespace net