Make sure filter buffer is flushed after it fills its output quota...

net/url_request/url_request_job.cc

 // Copyright (c) 2006-2008 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/message_loop.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/auth.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job_metrics.h"
 #include "net/url_request/url_request_job_tracker.h"
 
 // Buffer size allocated when de-compressing data.
 static const int kFilterBufSize = 32 * 1024;
 
 URLRequestJob::URLRequestJob(URLRequest* request)
     : request_(request),
       done_(false),
+      filter_needs_more_output_space_(false),
       read_buffer_(NULL),
       read_buffer_len_(0),
       has_handled_response_(false),
       expected_content_size_(-1) {
   is_profiling_ = request->enable_profiling();
   if (is_profiling()) {
     metrics_.reset(new URLRequestJobMetrics());
     metrics_->start_time_ = TimeTicks::Now();
   }
   g_url_request_job_tracker.AddNewJob(this);
@@ skipping 124 matching lines @@
   DCHECK(read_buffer_ != NULL);  // we need to have a buffer to fill
   DCHECK(read_buffer_len_ > 0);  // sanity check
   DCHECK(read_buffer_len_ < 1000000);  // sanity check
 
   bool rv = false;
   *bytes_read = 0;
 
   if (is_done())
     return true;
 
-  if (!filter_->stream_data_len()) {
+  if (!filter_needs_more_output_space_ && !filter_->stream_data_len()) {
     // We don't have any raw data to work with, so
     // read from the socket.
-
     int filtered_data_read;
     if (ReadRawDataForFilter(&filtered_data_read)) {
       if (filtered_data_read > 0) {
-        filter_->FlushStreamBuffer(filtered_data_read);
+        filter_->FlushStreamBuffer(filtered_data_read);  // Give data to filter.
       } else {
         return true;  // EOF
       }
     } else {
       return false;  // IO Pending (or error)
     }
   }
 
-  if (filter_->stream_data_len() && !is_done()) {
-    // Get filtered data
+  if ((filter_->stream_data_len() || filter_needs_more_output_space_)
+      && !is_done()) {
+    // Get filtered data.
     int filtered_data_len = read_buffer_len_;
     Filter::FilterStatus status;
+    int output_buffer_size = filtered_data_len;
     status = filter_->ReadData(read_buffer_, &filtered_data_len);
+
+    if (filter_needs_more_output_space_ && 0 == filtered_data_len) {
+      // filter_needs_more_output_space_ was mistaken... there are no more bytes
+      // 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;
         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;
           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;
         rv = true;
         break;
       }
       case Filter::FILTER_ERROR: {
+        filter_needs_more_output_space_ = false;
         // TODO: Figure out a better error code.
         NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, net::ERR_FAILED));
         rv = false;
         break;
       }
       default: {
         NOTREACHED();
+        filter_needs_more_output_space_ = false;
         rv = false;
         break;
       }
     }
   } else {
     // we are done, or there is no data left.
     rv = true;
   }
 
   if (rv) {
@@ skipping 264 matching lines @@
   // If the request is gone, we must be cancelled.
   return URLRequestStatus(URLRequestStatus::CANCELED,
                           net::ERR_ABORTED);
 }
 
 void URLRequestJob::SetStatus(const URLRequestStatus &status) {
   if (request_)
     request_->set_status(status);
 }