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

net/base/filter.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/base/filter.h"
 
 #include "base/string_util.h"
 #include "net/base/gzip_filter.h"
 #include "net/base/bzip2_filter.h"
 #include "net/base/sdch_filter.h"
@@ skipping 210 matching lines @@
       next_filter_(NULL),
       last_status_(FILTER_NEED_MORE_DATA) {
 }
 
 Filter::~Filter() {}
 
 bool Filter::InitBuffer(int buffer_size) {
   if (buffer_size < 0 || stream_buffer())
     return false;
 
-  stream_buffer_.reset(new char[buffer_size]);
+  stream_buffer_ = new net::IOBuffer(buffer_size);
 
   if (stream_buffer()) {
     stream_buffer_size_ = buffer_size;
     return true;
   }
 
   return false;
 }
 
 
@@ skipping 26 matching lines @@
 
 Filter::FilterStatus Filter::ReadData(char* dest_buffer, int* dest_len) {
   if (last_status_ == FILTER_ERROR)
     return last_status_;
   if (!next_filter_.get())
     return last_status_ = ReadFilteredData(dest_buffer, dest_len);
   if (last_status_ == FILTER_NEED_MORE_DATA && !stream_data_len())
     return next_filter_->ReadData(dest_buffer, dest_len);
   if (next_filter_->last_status() == FILTER_NEED_MORE_DATA) {
     // Push data into next filter's input.
-    char* next_buffer = next_filter_->stream_buffer();
+    net::IOBuffer* next_buffer = next_filter_->stream_buffer();
     int next_size = next_filter_->stream_buffer_size();
-    last_status_ = ReadFilteredData(next_buffer, &next_size);
+    last_status_ = ReadFilteredData(next_buffer->data(), &next_size);
     next_filter_->FlushStreamBuffer(next_size);
     switch (last_status_) {
       case FILTER_ERROR:
         return last_status_;
 
       case FILTER_NEED_MORE_DATA:
         return next_filter_->ReadData(dest_buffer, dest_len);
 
       case FILTER_OK:
       case FILTER_DONE:
         break;
     }
   }
   FilterStatus status = next_filter_->ReadData(dest_buffer, dest_len);
   // We could loop to fill next_filter_ if it needs data, but we have to be
   // careful about output buffer.  Simpler is to just wait until we are called
   // again, and return FILTER_OK.
   return (status == FILTER_ERROR) ? FILTER_ERROR : FILTER_OK;
 }
 
 bool Filter::FlushStreamBuffer(int stream_data_len) {
   if (stream_data_len <= 0 || stream_data_len > stream_buffer_size_)
     return false;
 
   // bail out if there are more data in the stream buffer to be filtered.
   if (!stream_buffer() || stream_data_len_)
     return false;
 
-  next_stream_data_ = stream_buffer();
+  next_stream_data_ = stream_buffer()->data();
   stream_data_len_ = stream_data_len;
   return true;
 }
 
 void Filter::SetURL(const GURL& url) {
   url_ = url;
   if (next_filter_.get())
     next_filter_->SetURL(url);
 }
 
 void Filter::SetMimeType(const std::string& mime_type) {
   mime_type_ = mime_type;
   if (next_filter_.get())
     next_filter_->SetMimeType(mime_type);
 }
 
 void Filter::SetConnectTime(const base::Time& time, bool was_cached) {
   connect_time_ = time;
   was_cached_ = was_cached;
   if (next_filter_.get())
     next_filter_->SetConnectTime(time, was_cached_);
 }