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

net/base/bzip2_filter_unittest.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 <fstream>
 #include <iostream>
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
@@ skipping 104 matching lines @@
     const char* encode_next = encoded_source;
     int encode_avail_size = encoded_source_len;
 
     Filter::FilterStatus code = Filter::FILTER_OK;
     while (code != Filter::FILTER_DONE) {
       int encode_data_len;
       if (get_extra_data && !encode_avail_size)
         break;
       encode_data_len = std::min(encode_avail_size,
                                  filter->stream_buffer_size());
-      memcpy(filter->stream_buffer(), encode_next, encode_data_len);
+      memcpy(filter->stream_buffer()->data(), encode_next, encode_data_len);
       filter->FlushStreamBuffer(encode_data_len);
       encode_next += encode_data_len;
       encode_avail_size -= encode_data_len;
 
       while (1) {
         int decode_data_len = std::min(decode_avail_size, output_buffer_size);
 
         code = filter->ReadData(decode_next, &decode_data_len);
         decode_next += decode_data_len;
         decode_avail_size -= decode_data_len;
@@ skipping 19 matching lines @@
   // Unsafe function to use filter to decode compressed data.
   // Parameters: Source and source_len are compressed data and its size.
   // Dest is the buffer for decoding results. Upon entry, *dest_len is the size
   // of the dest buffer. Upon exit, *dest_len is the number of chars written
   // into the buffer.
   Filter::FilterStatus DecodeAllWithFilter(Filter* filter,
                                            const char* source,
                                            int source_len,
                                            char* dest,
                                            int* dest_len) {
-    memcpy(filter->stream_buffer(), source, source_len);
+    memcpy(filter->stream_buffer()->data(), source, source_len);
     filter->FlushStreamBuffer(source_len);
     return filter->ReadData(dest, dest_len);
   }
 
   const char* source_buffer() const { return source_buffer_.data(); }
   int source_len() const {
     return static_cast<int>(source_buffer_.size()) - kExtraDataBufferSize;
   }
 
   std::string source_buffer_;
 
   scoped_ptr<bz_stream> bzip2_data_stream_;
   char* bzip2_encode_buffer_;
   int bzip2_encode_len_;
 };
 
 // Basic scenario: decoding bzip2 data with big enough buffer.
 TEST_F(BZip2FilterUnitTest, DecodeBZip2) {
   // Decode the compressed data with filter
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_BZIP2);
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, kDefaultBufferSize));
   ASSERT_TRUE(filter.get());
-  memcpy(filter->stream_buffer(), bzip2_encode_buffer_, bzip2_encode_len_);
+  memcpy(filter->stream_buffer()->data(), bzip2_encode_buffer_,
+         bzip2_encode_len_);
   filter->FlushStreamBuffer(bzip2_encode_len_);
 
   char bzip2_decode_buffer[kDefaultBufferSize];
   int bzip2_decode_size = kDefaultBufferSize;
   Filter::FilterStatus result =
       filter->ReadData(bzip2_decode_buffer, &bzip2_decode_size);
   ASSERT_EQ(Filter::FILTER_DONE, result);
 
   // Compare the decoding result with source data
   EXPECT_TRUE(bzip2_decode_size == source_len());
@@ skipping 179 matching lines @@
   DecodeAndCompareWithFilter(filter.get(),
                              source_buffer(),
                              source_len() + kExtraDataBufferSize,
                              more_data,
                              more_data_len,
                              kDefaultBufferSize,
                              true);
 }
 
 }  // namespace