net: Notify the http job and cache transaction about a filter

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 43 matching lines @@
 void URLRequestJob::DetachRequest() {
   request_ = NULL;
 }
 
 // This function calls ReadData to get stream data. If a filter exists, passes
 // the data to the attached filter. Then returns the output from filter back to
 // the caller.
 bool URLRequestJob::Read(IOBuffer* buf, int buf_size, int *bytes_read) {
   bool rv = false;
 
-  DCHECK_LT(buf_size, 1000000);  // sanity check
+  DCHECK_LT(buf_size, 1000000);  // Sanity check.
   DCHECK(buf);
   DCHECK(bytes_read);
   DCHECK(filtered_read_buffer_ == NULL);
   DCHECK_EQ(0, filtered_read_buffer_len_);
 
   *bytes_read = 0;
 
-  // Skip Filter if not present
+  // Skip Filter if not present.
   if (!filter_.get()) {
     rv = ReadRawDataHelper(buf, buf_size, bytes_read);
   } else {
     // Save the caller's buffers while we do IO
     // in the filter's buffers.
     filtered_read_buffer_ = buf;
     filtered_read_buffer_len_ = buf_size;
 
     if (ReadFilteredData(bytes_read)) {
-      rv = true;   // we have data to return
+      rv = true;   // We have data to return.
+
+      // It is fine to call DoneReading even if ReadFilteredData receives 0
+      // bytes from the net, but we avoid making that call if we know for
+      // sure that's the case (ReadRawDataHelper path).
+      if (*bytes_read == 0)
+        DoneReading();
     } else {
-      rv = false;  // error, or a new IO is pending
+      rv = false;  // Error, or a new IO is pending.
     }
   }
   if (rv && *bytes_read == 0)
     NotifyDone(URLRequestStatus());
   return rv;
 }
 
 void URLRequestJob::StopCaching() {
   // Nothing to do here.
 }
@@ skipping 256 matching lines @@
   // survival until we can get out of this method.
   scoped_refptr<URLRequestJob> self_preservation(this);
 
   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)) {
+      if (!filter_bytes_read)
+        DoneReading();
       request_->NotifyReadCompleted(filter_bytes_read);
     }
   } else {
     request_->NotifyReadCompleted(bytes_read);
   }
   DVLOG(1) << __FUNCTION__ << "() "
            << "\"" << (request_ ? request_->url().spec() : "???") << "\""
            << " pre bytes read = " << bytes_read
            << " pre total = " << prefilter_bytes_read_
            << " post total = " << postfilter_bytes_read_;
@@ skipping 68 matching lines @@
     request_->Restart();
 }
 
 bool URLRequestJob::ReadRawData(IOBuffer* buf, int buf_size,
                                 int *bytes_read) {
   DCHECK(bytes_read);
   *bytes_read = 0;
   return true;
 }
 
+void URLRequestJob::DoneReading() {
+  // Do nothing.
+}
+
 void URLRequestJob::FilteredDataRead(int bytes_read) {
   DCHECK(filter_.get());  // don't add data if there is no filter
   filter_->FlushStreamBuffer(bytes_read);
 }
 
 bool URLRequestJob::ReadFilteredData(int* bytes_read) {
   DCHECK(filter_.get());  // don't add data if there is no filter
   DCHECK(filtered_read_buffer_ != NULL);  // we need to have a buffer to fill
   DCHECK_GT(filtered_read_buffer_len_, 0);  // sanity check
   DCHECK_LT(filtered_read_buffer_len_, 1000000);  // sanity check
@@ skipping 210 matching lines @@
 }
 
 bool URLRequestJob::FilterHasData() {
     return filter_.get() && filter_->stream_data_len();
 }
 
 void URLRequestJob::UpdatePacketReadTimes() {
 }
 
 }  // namespace net