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

net/proxy/proxy_script_fetcher.cc

 // Copyright (c) 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/proxy/proxy_script_fetcher.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
+#include "base/ref_counted.h"
 #include "base/string_util.h"
+#include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request.h"
 
 // TODO(eroman): 
 //   - Support auth-prompts.
 
 namespace net {
 
 namespace {
 
@@ skipping 50 matching lines @@
 
   // Factory for creating the time-out task. This takes care of revoking
   // outstanding tasks when |this| is deleted.
   ScopedRunnableMethodFactory<ProxyScriptFetcherImpl> task_factory_;
 
   // The context used for making network requests.
   URLRequestContext* url_request_context_;
 
   // Buffer that URLRequest writes into.
   enum { kBufSize = 4096 };
-  char buf_[kBufSize];
+  scoped_refptr<net::IOBuffer> buf_;
 
   // The next ID to use for |cur_request_| (monotonically increasing).
   int next_id_;
 
   // The current (in progress) request, or NULL.
   scoped_ptr<URLRequest> cur_request_;
 
   // State for current request (only valid when |cur_request_| is not NULL):
 
   // Unique ID for the current request.
   int cur_request_id_;
 
   // Callback to invoke on completion of the fetch.
   CompletionCallback* callback_;
 
   // Holds the error condition that was hit on the current request, or OK.
   int result_code_;
 
   // Holds the bytes read so far. Will not exceed |max_response_bytes|. This
   // buffer is owned by the owner of |callback|.
   std::string* result_bytes_;
 };
 
 ProxyScriptFetcherImpl::ProxyScriptFetcherImpl(
     URLRequestContext* url_request_context)
     : ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       url_request_context_(url_request_context),
+      buf_(new net::IOBuffer(kBufSize)),
       next_id_(0),
       cur_request_(NULL),
       cur_request_id_(0),
       callback_(NULL),
       result_code_(OK),
       result_bytes_(NULL) {
   DCHECK(url_request_context);
 }
 
 ProxyScriptFetcherImpl::~ProxyScriptFetcherImpl() {
@@ skipping 92 matching lines @@
                                              int num_bytes) {
   DCHECK(request == cur_request_.get());
   if (num_bytes > 0) {
     // Enforce maximum size bound.
     if (num_bytes + result_bytes_->size() >
         static_cast<size_t>(max_response_bytes)) {
       result_code_ = ERR_FILE_TOO_BIG;
       request->Cancel();
       return;
     }
-    result_bytes_->append(buf_, num_bytes);
+    result_bytes_->append(buf_->data(), num_bytes);
     ReadBody(request);
   } else {  // Error while reading, or EOF
     OnResponseCompleted(request);
   }
 }
 
 void ProxyScriptFetcherImpl::OnResponseCompleted(URLRequest* request) {
   DCHECK(request == cur_request_.get());
 
   // Use |result_code_| as the request's error if we have already set it to
@@ skipping 61 matching lines @@
 }
 
 // static
 size_t ProxyScriptFetcher::SetSizeConstraintForUnittest(size_t size_bytes) {
   size_t prev = max_response_bytes;
   max_response_bytes = size_bytes;
   return prev;
 }
 
 }  // namespace net