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

net/http/http_network_transaction.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/http/http_network_transaction.h"
 
 #include "base/scoped_ptr.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
@@ skipping 34 matching lines @@
       using_proxy_(false),
       using_tunnel_(false),
       establishing_tunnel_(false),
       request_headers_bytes_sent_(0),
       header_buf_capacity_(0),
       header_buf_len_(0),
       header_buf_body_offset_(-1),
       header_buf_http_offset_(-1),
       content_length_(-1),  // -1 means unspecified.
       content_read_(0),
-      read_buf_(NULL),
       read_buf_len_(0),
       next_state_(STATE_NONE) {
 #if defined(OS_WIN)
   // TODO(port): Port the SSLConfigService class to Linux and Mac OS X.
   session->ssl_config_service()->GetSSLConfig(&ssl_config_);
 #endif
 }
 
 int HttpNetworkTransaction::Start(const HttpRequestInfo* request_info,
                                   CompletionCallback* callback) {
@@ skipping 61 matching lines @@
       AuthPath(target));
 
   next_state_ = STATE_INIT_CONNECTION;
   connection_.set_socket(NULL);
   connection_.Reset();
 
   // Reset the other member variables.
   ResetStateForRestart();
 }
 
-int HttpNetworkTransaction::Read(char* buf, int buf_len,
+int HttpNetworkTransaction::Read(IOBuffer* buf, int buf_len,
                                  CompletionCallback* callback) {
   DCHECK(response_.headers);
   DCHECK(buf);
   DCHECK(buf_len > 0);
 
   if (!connection_.is_initialized())
     return 0;  // connection_ has been reset.  Treat like EOF.
 
   read_buf_ = buf;
   read_buf_len_ = buf_len;
@@ skipping 571 matching lines @@
 
   next_state_ = STATE_READ_BODY_COMPLETE;
 
   // We may have already consumed the indicated content length.
   if (content_length_ != -1 && content_read_ >= content_length_)
     return 0;
 
   // We may have some data remaining in the header buffer.
   if (header_buf_.get() && header_buf_body_offset_ < header_buf_len_) {
     int n = std::min(read_buf_len_, header_buf_len_ - header_buf_body_offset_);
-    memcpy(read_buf_, header_buf_.get() + header_buf_body_offset_, n);
+    memcpy(read_buf_->data(), header_buf_.get() + header_buf_body_offset_, n);
     header_buf_body_offset_ += n;
     if (header_buf_body_offset_ == header_buf_len_) {
       header_buf_.reset();
       header_buf_capacity_ = 0;
       header_buf_len_ = 0;
       header_buf_body_offset_ = -1;
     }
     return n;
   }
 
-  return connection_.socket()->Read(read_buf_, read_buf_len_, &io_callback_);
+  return connection_.socket()->Read(read_buf_->data(), read_buf_len_,
+                                    &io_callback_);
 }
 
 int HttpNetworkTransaction::DoReadBodyComplete(int result) {
   // We are done with the Read call.
 
   bool unfiltered_eof = (result == 0);
 
   // Filter incoming data if appropriate.  FilterBuf may return an error.
   if (result > 0 && chunked_decoder_.get()) {
-    result = chunked_decoder_->FilterBuf(read_buf_, result);
+    result = chunked_decoder_->FilterBuf(read_buf_->data(), result);
     if (result == 0 && !chunked_decoder_->reached_eof()) {
       // Don't signal completion of the Read call yet or else it'll look like
       // we received end-of-file.  Wait for more data.
       next_state_ = STATE_READ_BODY;
       return OK;
     }
   }
 
   bool done = false, keep_alive = false;
   if (result < 0) {
@@ skipping 502 matching lines @@
   if (target == HttpAuth::AUTH_PROXY) {
     auth_info->host = ASCIIToWide(proxy_info_.proxy_server());
   } else {
     DCHECK(target == HttpAuth::AUTH_SERVER);
     auth_info->host = ASCIIToWide(request_->url.host());
   }
   response_.auth_challenge = auth_info;
 }
 
 }  // namespace net