Add the actual data being read to the OnBytesRead callback, take two....

net/url_request/url_request_job.h

 // Copyright (c) 2010 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_JOB_H_
 #define NET_URL_REQUEST_URL_REQUEST_JOB_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 295 matching lines @@
 
  private:
   // Size of filter input buffers used by this class.
   static const int kFilterBufSize;
 
   // When data filtering is enabled, this function is used to read data
   // for the filter.  Returns true if raw data was read.  Returns false if
   // an error occurred (or we are waiting for IO to complete).
   bool ReadRawDataForFilter(int *bytes_read);
 
+  // Invokes ReadRawData and records bytes read if the read completes
+  // synchronously.
+  bool ReadRawDataHelper(net::IOBuffer* buf, int buf_size, int* bytes_read);
+
   // Called in response to a redirect that was not canceled to follow the
   // redirect. The current job will be replaced with a new job loading the
   // given redirect destination.
   void FollowRedirect(const GURL& location, int http_status_code);
 
-  // Updates the profiling info and notifies observers that bytes_read bytes
-  // have been read.
+  // Called after every raw read. If |bytes_read| is > 0, this indicates
+  // a successful read of |bytes_read| unfiltered bytes. If |bytes_read|
+  // is 0, this indicates that there is no additional data to read. If
+  // |bytes_read| is < 0, an error occurred and no bytes were read.
+  void OnRawReadComplete(int bytes_read);
+
+  // Updates the profiling info and notifies observers that an additional
+  // |bytes_read| unfiltered bytes have been read for this job.
   void RecordBytesRead(int bytes_read);
 
   // Called to query whether there is data available in the filter to be read
   // out.
   bool FilterHasData();
 
   // Record packet arrival times for possible use in histograms.
   void UpdatePacketReadTimes();
 
   void RecordCompressionHistograms();
@@ skipping 10 matching lines @@
   scoped_ptr<Filter> filter_;
 
   // If the filter filled its output buffer, then there is a change that it
   // still has internal data to emit, and this flag is set.
   bool filter_needs_more_output_space_;
 
   // When we filter data, we receive data into the filter buffers.  After
   // processing the filtered data, we return the data in the caller's buffer.
   // While the async IO is in progress, we save the user buffer here, and
   // when the IO completes, we fill this in.
-  scoped_refptr<net::IOBuffer> read_buffer_;
-  int read_buffer_len_;
+  scoped_refptr<net::IOBuffer> filtered_read_buffer_;
+  int filtered_read_buffer_len_;
+
+  // We keep a pointer to the read buffer while asynchronous reads are
+  // in progress, so we are able to pass those bytes to job observers.
+  scoped_refptr<net::IOBuffer> raw_read_buffer_;
 
   // Used by HandleResponseIfNecessary to track whether we've sent the
   // OnResponseStarted callback and potentially redirect callbacks as well.
   bool has_handled_response_;
 
   // Expected content size
   int64 expected_content_size_;
 
   // Set when a redirect is deferred.
   GURL deferred_redirect_url_;
   int deferred_redirect_status_code_;
 
   //----------------------------------------------------------------------------
   // Data used for statistics gathering in some instances.  This data is only
   // used for histograms etc., and is not required.  It is optionally gathered
   // based on the settings of several control variables.
 
   // Enable recording of packet arrival times for histogramming.
   bool packet_timing_enabled_;
 
   // TODO(jar): improve the quality of the gathered info by gathering most times
   // at a lower point in the network stack, assuring we have actual packet
   // boundaries, rather than approximations.  Also note that input byte count
   // as gathered here is post-SSL, and post-cache-fetch, and does not reflect
   // true packet arrival times in such cases.
 
-  // Total number of bytes read from network (or cache) and and typically handed
+  // Total number of bytes read from network (or cache) and typically handed
   // to filter to process.  Used to histogram compression ratios, and error
   // recovery scenarios in filters.
   int64 filter_input_byte_count_;
 
   // The number of bytes that have been accounted for in packets (where some of
   // those packets may possibly have had their time of arrival recorded).
   int64 bytes_observed_in_packets_;
 
   // Limit on the size of the array packet_times_.  This can be set to
   // zero, and then no packet times will be gathered.
@@ skipping 11 matching lines @@
   base::Time final_packet_time_;
 
   // The count of the number of packets, some of which may not have been timed.
   // We're ignoring overflow, as 1430 x 2^31 is a LOT of bytes.
   int observed_packet_count_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestJob);
 };
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_JOB_H_