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);
 
-  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 {
-    postfilter_bytes_read_ += bytes_read;
     request_->delegate()->OnReadCompleted(request_, bytes_read);
   }
+  VLOG(21) << __FUNCTION__ << "() "

[rvargas (doing something else), 2011/05/21 01:24:50]

DVLOG. I'm still not too happy about the 21... it's not like these files have
DVLOG at any level so it goes from 0 to level 21.

Correct me if I'm wrong, but the idea behind VLOG is to filter features based on
file name, not that a given feature will have a log level. In other words,
activating log at level 21 without setting a filter on file names will just give
you every possible log from everybody (unless somebody decided to use 40 or
something like that), so I just don't get your comment about not interfering
with somebody else.

Even if the downloads code uses level 20/21, it looks inappropriate to expect
other random files to follow the same convention. To me, level 21 means that I
should expect (at some point) 20 progressive levels of more and more logging
(from the same file) below the current level.

[ahendrickson, 2011/05/22 06:43:34]

Reduced the number to 2 (in case anyone adds VLOGs and doesn't want to be
spammed with this.

+           << "\"" << (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 64 matching lines @@
 void URLRequestJob::OnRawReadComplete(int bytes_read) {
   DCHECK(raw_read_buffer_);
   if (bytes_read > 0) {
     RecordBytesRead(bytes_read);
   }
   raw_read_buffer_ = NULL;
 }
 
 void URLRequestJob::RecordBytesRead(int bytes_read) {
   filter_input_byte_count_ += bytes_read;
+  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_;
   UpdatePacketReadTimes();  // Facilitate stats recording if it is active.
   g_url_request_job_tracker.OnBytesRead(this, raw_read_buffer_->data(),
                                         bytes_read);
 }
 
 bool URLRequestJob::FilterHasData() {
     return filter_.get() && filter_->stream_data_len();
 }
 
 void URLRequestJob::UpdatePacketReadTimes() {
 }
 
 }  // namespace net