Change URLRequest to use a ref-counted buffer for actual IO....

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/io_buffer.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"
 
 using base::Time;
 using base::TimeTicks;
 
 // Buffer size allocated when de-compressing data.
 static const int kFilterBufSize = 32 * 1024;
@@ skipping 69 matching lines @@
 void URLRequestJob::ContinueDespiteLastError() {
   // Implementations should know how to recover from errors they generate.
   // If this code was reached, we are trying to recover from an error that
   // we don't know how to recover from.
   NOTREACHED();
 }
 
 // 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(char* buf, int buf_size, int *bytes_read) {
+bool URLRequestJob::Read(net::IOBuffer* buf, int buf_size, int *bytes_read) {
   bool rv = false;
 
   DCHECK_LT(buf_size, 1000000);  // sanity check
   DCHECK(buf);
   DCHECK(bytes_read);
 
   *bytes_read = 0;
 
   // Skip Filter if not present
   if (!filter_.get()) {
@@ skipping 22 matching lines @@
 
   DCHECK(bytes_read);
   DCHECK(filter_.get());
 
   *bytes_read = 0;
 
   // Get more pre-filtered data if needed.
   // TODO(mbelshe): is it possible that the filter needs *MORE* data
   //    when there is some data already in the buffer?
   if (!filter_->stream_data_len() && !is_done()) {
-    char* stream_buffer = filter_->stream_buffer();
+    net::IOBuffer* stream_buffer = filter_->stream_buffer();
     int stream_buffer_size = filter_->stream_buffer_size();
     rv = ReadRawData(stream_buffer, stream_buffer_size, bytes_read);
     if (rv && *bytes_read > 0)
       RecordBytesRead(*bytes_read);
   }
   return rv;
 }
 
 void URLRequestJob::FilteredDataRead(int bytes_read) {
   DCHECK(filter_.get());  // don't add data if there is no filter
@@ skipping 25 matching lines @@
       }
     } else {
       return false;  // IO Pending (or error)
     }
   }
 
   if (filter_->stream_data_len() && !is_done()) {
     // Get filtered data
     int filtered_data_len = read_buffer_len_;
     Filter::FilterStatus status;
-    status = filter_->ReadData(read_buffer_, &filtered_data_len);
+    status = filter_->ReadData(read_buffer_->data(), &filtered_data_len);
     switch (status) {
       case Filter::FILTER_DONE: {
         *bytes_read = filtered_data_len;
         rv = true;
         break;
       }
       case Filter::FILTER_NEED_MORE_DATA: {
         // 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
@@ skipping 35 matching lines @@
   if (rv) {
     // When we successfully finished a read, we no longer need to
     // save the caller's buffers.  For debugging purposes, we clear
     // them out.
     read_buffer_ = NULL;
     read_buffer_len_ = 0;
   }
   return rv;
 }
 
-bool URLRequestJob::ReadRawData(char* buf, int buf_size, int *bytes_read) {
+bool URLRequestJob::ReadRawData(net::IOBuffer* buf, int buf_size,
+                                int *bytes_read) {
   DCHECK(bytes_read);
   *bytes_read = 0;
   NotifyDone(URLRequestStatus());
   return false;
 }
 
 URLRequestJobMetrics* URLRequestJob::RetrieveMetrics() {
   if (is_profiling())
     return metrics_.release();
   else
@@ skipping 228 matching lines @@
     return request_->status();
   // 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);
 }