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

net/base/gzip_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 156 matching lines @@
     int decode_avail_size = kDefaultBufferSize;
 
     const char* encode_next = encoded_source;
     int encode_avail_size = encoded_source_len;
 
     int code = Filter::FILTER_OK;
     while (code != Filter::FILTER_DONE) {
       int encode_data_len;
       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 13 matching lines @@
     EXPECT_EQ(memcmp(source, decode_buffer, source_len), 0);
   }
 
   // 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.
   int 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()); }
 
   std::string source_buffer_;
 
   char* deflate_encode_buffer_;
   int deflate_encode_len_;
 
   char* gzip_encode_buffer_;
   int gzip_encode_len_;
 };
 
 // Basic scenario: decoding deflate data with big enough buffer.
 TEST_F(GZipUnitTest, DecodeDeflate) {
   // Decode the compressed data with filter
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_DEFLATE);
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, kDefaultBufferSize));
   ASSERT_TRUE(filter.get());
-  memcpy(filter->stream_buffer(), deflate_encode_buffer_, deflate_encode_len_);
+  memcpy(filter->stream_buffer()->data(), deflate_encode_buffer_,
+         deflate_encode_len_);
   filter->FlushStreamBuffer(deflate_encode_len_);
 
   char deflate_decode_buffer[kDefaultBufferSize];
   int deflate_decode_size = kDefaultBufferSize;
   filter->ReadData(deflate_decode_buffer, &deflate_decode_size);
 
   // Compare the decoding result with source data
   EXPECT_TRUE(deflate_decode_size == source_len());
   EXPECT_EQ(memcmp(source_buffer(), deflate_decode_buffer, source_len()), 0);
 }
 
 // Basic scenario: decoding gzip data with big enough buffer.
 TEST_F(GZipUnitTest, DecodeGZip) {
   // Decode the compressed data with filter
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_GZIP);
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, kDefaultBufferSize));
   ASSERT_TRUE(filter.get());
-  memcpy(filter->stream_buffer(), gzip_encode_buffer_, gzip_encode_len_);
+  memcpy(filter->stream_buffer()->data(), gzip_encode_buffer_,
+         gzip_encode_len_);
   filter->FlushStreamBuffer(gzip_encode_len_);
 
   char gzip_decode_buffer[kDefaultBufferSize];
   int gzip_decode_size = kDefaultBufferSize;
   filter->ReadData(gzip_decode_buffer, &gzip_decode_size);
 
   // Compare the decoding result with source data
   EXPECT_TRUE(gzip_decode_size == source_len());
   EXPECT_EQ(memcmp(source_buffer(), gzip_decode_buffer, source_len()), 0);
 }
 
 // SDCH scenario: decoding gzip data when content type says sdch,gzip.
 // This tests that sdch will degrade to pass through, and is what allows robust
 // handling when the response *might* be sdch,gzip by simply adding in the
 // tentative sdch decode.
 // All test code is otherwise modeled after the "basic" scenario above.
 TEST_F(GZipUnitTest, DecodeGZipWithMistakenSdch) {
   // Decode the compressed data with filter
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
   filter_types.push_back(Filter::FILTER_TYPE_GZIP);
   scoped_ptr<Filter> filter(Filter::Factory(filter_types, kDefaultBufferSize));
   ASSERT_TRUE(filter.get());
-  memcpy(filter->stream_buffer(), gzip_encode_buffer_, gzip_encode_len_);
+  memcpy(filter->stream_buffer()->data(), gzip_encode_buffer_,
+         gzip_encode_len_);
   filter->FlushStreamBuffer(gzip_encode_len_);
 
   char gzip_decode_buffer[kDefaultBufferSize];
   int gzip_decode_size = kDefaultBufferSize;
   filter->ReadData(gzip_decode_buffer, &gzip_decode_size);
 
   // Compare the decoding result with source data
   EXPECT_TRUE(gzip_decode_size == source_len());
   EXPECT_EQ(memcmp(source_buffer(), gzip_decode_buffer, source_len()), 0);
 }
@@ skipping 114 matching lines @@
   int corrupt_decode_size = kDefaultBufferSize;
 
   int code = DecodeAllWithFilter(filter.get(), corrupt_data, corrupt_data_len,
                                  corrupt_decode_buffer, &corrupt_decode_size);
 
   // Expect failures
   EXPECT_TRUE(code == Filter::FILTER_ERROR);
 }
 
 }  // namespace