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

net/base/filter.h

 // 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.
 //
 // Filter performs filtering on data streams. Sample usage:
 //
 //   IStream* pre_filter_source;
 //   ...
 //   Filter* filter = Filter::Factory(filter_type, size);
 //   int pre_filter_data_len = filter->stream_buffer_size();
@@ skipping 17 matching lines @@
 
 #ifndef NET_BASE_FILTER_H__
 #define NET_BASE_FILTER_H__
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
+#include "net/base/io_buffer.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
 class Filter {
  public:
   // Return values of function ReadFilteredData.
   enum FilterStatus {
     // Read filtered data successfully
     FILTER_OK,
     // Read filtered data successfully, and the data in the buffer has been
@@ skipping 36 matching lines @@
   // (decoding) order. For example, types[0] = "sdch", types[1] = "gzip" will
   // cause data to first be gunizip filtered, and the resulting output from that
   // filter will be sdch decoded.
   static Filter* Factory(const std::vector<FilterType>& filter_types,
                          int buffer_size);
 
   // External call to obtain data from this filter chain.  If ther is no
   // next_filter_, then it obtains data from this specific filter.
   FilterStatus ReadData(char* dest_buffer, int* dest_len);
 
-  // Returns a pointer to the beginning of stream_buffer_.
-  char* stream_buffer() const { return stream_buffer_.get(); }
+  // Returns a pointer to the stream_buffer_.
+  net::IOBuffer* stream_buffer() const { return stream_buffer_.get(); }
 
   // Returns the maximum size of stream_buffer_ in number of chars.
   int stream_buffer_size() const { return stream_buffer_size_; }
 
   // Returns the total number of chars remaining in stream_buffer_ to be
   // filtered.
   //
   // If the function returns 0 then all data have been filtered and the caller
   // is safe to copy new data into stream_buffer_.
   int stream_data_len() const { return stream_data_len_; }
@@ skipping 64 matching lines @@
   static Filter* PrependNewFilter(FilterType type_id, int buffer_size,
                                   Filter* filter_list);
 
   FilterStatus last_status() const { return last_status_; }
 
   base::Time connect_time() const { return connect_time_; }
 
   bool was_cached() const { return was_cached_; }
 
   // Buffer to hold the data to be filtered.
-  scoped_array<char> stream_buffer_;
+  scoped_refptr<net::IOBuffer> stream_buffer_;
 
   // Maximum size of stream_buffer_ in number of chars.
   int stream_buffer_size_;
 
   // Pointer to the next data in stream_buffer_ to be filtered.
   char* next_stream_data_;
 
   // Total number of remaining chars in stream_buffer_ to be filtered.
   int stream_data_len_;
 
@@ skipping 17 matching lines @@
   scoped_ptr<Filter> next_filter_;
   // Remember what status or local filter last returned so we can better handle
   // chained filters.
   FilterStatus last_status_;
 
   DISALLOW_COPY_AND_ASSIGN(Filter);
 };
 
 #endif  // NET_BASE_FILTER_H__