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

net/url_request/url_request_job.cc

 // Copyright (c) 2011 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/url_request/url_request_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 288 matching lines @@
   // The headers should be complete before reads complete
   DCHECK(has_handled_response_);
 
   OnRawReadComplete(bytes_read);
 
   // Don't notify if we had an error.
   if (!request_->status().is_success())
     return;
 
   // When notifying the delegate, the delegate can release the request
-  // (and thus release 'this').  After calling to the delgate, we must
+  // (and thus release 'this').  After calling to the delegate, we must
   // check the request pointer to see if it still exists, and return
   // immediately if it has been destroyed.  self_preservation ensures our
   // survival until we can get out of this method.
   scoped_refptr<URLRequestJob> self_preservation(this);
 
+  // If we get here, |prefilter_bytes_read_| was not updated in
+  // |ReadRawDataHelper()|.
   prefilter_bytes_read_ += bytes_read;
   if (filter_.get()) {
     // Tell the filter that it has more data
     FilteredDataRead(bytes_read);
 
     // Filter the data.
     int filter_bytes_read = 0;
     if (ReadFilteredData(&filter_bytes_read)) {
-      postfilter_bytes_read_ += filter_bytes_read;
       request_->delegate()->OnReadCompleted(request_, filter_bytes_read);
     }
   } else {
+    // If we get here, |postfilter_bytes_read_| was not updated in
+    // |ReadRawDataHelper()|.
     postfilter_bytes_read_ += bytes_read;
     request_->delegate()->OnReadCompleted(request_, bytes_read);
   }
+  VLOG(21) << __FUNCTION__ << "() "
+           << "\"" << (request_ ? request_->url().spec() : "???") << "\""
+           << " pre bytes read = " << bytes_read
+           << " pre total = " << prefilter_bytes_read_
+           << " post total = " << postfilter_bytes_read_;
 }
 
 void URLRequestJob::NotifyStartError(const URLRequestStatus &status) {
   DCHECK(!has_handled_response_);
   has_handled_response_ = true;
   if (request_) {
     request_->set_status(status);
     request_->ResponseStarted();
   }
 }
@@ skipping 121 matching lines @@
       // and we should have at least tried to fill up the filter's input buffer.
       // Correct the state, and try again.
       filter_needs_more_output_space_ = false;
       return ReadFilteredData(bytes_read);
     }
 
     switch (status) {
       case Filter::FILTER_DONE: {
         filter_needs_more_output_space_ = false;
         *bytes_read = filtered_data_len;
+        postfilter_bytes_read_ += filtered_data_len;
         rv = true;
         break;
       }
       case Filter::FILTER_NEED_MORE_DATA: {
         filter_needs_more_output_space_ =
             (filtered_data_len == output_buffer_size);
         // We have finished filtering all data currently in the buffer.
         // There might be some space left in the output buffer. One can
         // consider reading more data from the stream to feed the filter
         // and filling up the output buffer. This leads to more complicated
         // buffer management and data notification mechanisms.
         // We can revisit this issue if there is a real perf need.
         if (filtered_data_len > 0) {
           *bytes_read = filtered_data_len;
+          postfilter_bytes_read_ += filtered_data_len;
           rv = true;
         } else {
           // Read again since we haven't received enough data yet (e.g., we may
           // not have a complete gzip header yet)
           rv = ReadFilteredData(bytes_read);
         }
         break;
       }
       case Filter::FILTER_OK: {
         filter_needs_more_output_space_ =
             (filtered_data_len == output_buffer_size);
         *bytes_read = filtered_data_len;
+        postfilter_bytes_read_ += filtered_data_len;
         rv = true;
         break;
       }
       case Filter::FILTER_ERROR: {
         filter_needs_more_output_space_ = false;
         NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
                    ERR_CONTENT_DECODING_FAILED));
         rv = false;
         break;
       }
       default: {
         NOTREACHED();
         filter_needs_more_output_space_ = false;
         rv = false;
         break;
       }
     }
+    VLOG(21) << __FUNCTION__ << "() "
+             << "\"" << (request_ ? request_->url().spec() : "???") << "\""
+             << " rv = " << rv
+             << " post bytes read = " << filtered_data_len
+             << " pre total = " << prefilter_bytes_read_
+             << " post total = "
+             << postfilter_bytes_read_;
   } else {
     // we are done, or there is no data left.
     rv = true;
   }
 
   if (rv) {
     // When we successfully finished a read, we no longer need to
     // save the caller's buffers. Release our reference.
     filtered_read_buffer_ = NULL;
     filtered_read_buffer_len_ = 0;
@@ skipping 37 matching lines @@
                                       int* bytes_read) {
   DCHECK(!request_->status().is_io_pending());
   DCHECK(raw_read_buffer_ == NULL);
 
   // Keep a pointer to the read buffer, so we have access to it in the
   // OnRawReadComplete() callback in the event that the read completes
   // asynchronously.
   raw_read_buffer_ = buf;
   bool rv = ReadRawData(buf, buf_size, bytes_read);
 
+  // If |*bytes_read == 0|, that means we have data pending, so we will need to
+  // update |prefilter_bytes_read_| in |NotifyReadComplete()|.
+  if (*bytes_read > 0) {

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

You cannot evaluate bytes_read without first looking at the return value of
ReadRawData. Why not do this on OnRawReadComplete/RecordBytesRead?

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

Done.

+    prefilter_bytes_read_ += *bytes_read;
+    if (!filter_.get())
+      postfilter_bytes_read_ += *bytes_read;
+    VLOG(21) << __FUNCTION__ << "() "
+             << "\"" << (request_ ? request_->url().spec() : "???") << "\""
+             << " pre bytes read = " << *bytes_read
+             << " pre total = " << prefilter_bytes_read_
+             << " post total = " << postfilter_bytes_read_;
+  } else {
+    VLOG(21) << __FUNCTION__ << "() "
+             << "\"" << (request_ ? request_->url().spec() : "???") << "\""
+             << " error code = " << *bytes_read
+             << " io pending = " << request_->status().is_io_pending();
+  }
+
   if (!request_->status().is_io_pending()) {
     // If the read completes synchronously, either success or failure,
     // invoke the OnRawReadComplete callback so we can account for the
     // completed read.
     OnRawReadComplete(*bytes_read);
   }
   return rv;
 }
 
 void URLRequestJob::FollowRedirect(const GURL& location, int http_status_code) {
@@ skipping 20 matching lines @@
 }
 
 bool URLRequestJob::FilterHasData() {
     return filter_.get() && filter_->stream_data_len();
 }
 
 void URLRequestJob::UpdatePacketReadTimes() {
 }
 
 }  // namespace net