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

chrome/browser/net/url_fetcher.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 "chrome/browser/net/url_fetcher.h"
 
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
+#include "net/base/io_buffer.h"
+
+static const int kBufferSize = 4096;
 
 URLFetcher::URLFetcher(const GURL& url,
                        RequestType request_type,
                        Delegate* d)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
       core_(new Core(this, url, request_type, d))) {
 }
 
 URLFetcher::~URLFetcher() {
   core_->Stop();
 }
 
 URLFetcher::Core::Core(URLFetcher* fetcher,
                        const GURL& original_url,
                        RequestType request_type,
                        URLFetcher::Delegate* d)
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_loop_(MessageLoop::current()),
       io_loop_(ChromeThread::GetMessageLoop(ChromeThread::IO)),
       request_(NULL),
       load_flags_(net::LOAD_NORMAL),
       response_code_(-1),
+      buffer_(new net::IOBuffer(kBufferSize)),
       protect_entry_(URLFetcherProtectManager::GetInstance()->Register(
           original_url_.host())),
       num_retries_(0) {
 }
 
 void URLFetcher::Core::Start() {
   DCHECK(delegate_loop_);
   DCHECK(io_loop_);
   DCHECK(request_context_) << "We need an URLRequestContext!";
   io_loop_->PostDelayedTask(FROM_HERE, NewRunnableMethod(
@@ skipping 15 matching lines @@
     response_code_ = request_->GetResponseCode();
     response_headers_ = request_->response_headers();
   }
 
   int bytes_read = 0;
   // Some servers may treat HEAD requests as GET requests.  To free up the
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
   // about is the response code and headers, which we already have).
   if (request_->status().is_success() && (request_type_ != HEAD))
-    request_->Read(buffer_, sizeof(buffer_), &bytes_read);
+    request_->Read(buffer_, kBufferSize, &bytes_read);
   OnReadCompleted(request_, bytes_read);
 }
 
 void URLFetcher::Core::OnReadCompleted(URLRequest* request, int bytes_read) {
   DCHECK(request == request_);
   DCHECK(MessageLoop::current() == io_loop_);
 
   url_ = request->url();
 
   do {
     if (!request_->status().is_success() || bytes_read <= 0)
       break;
-    data_.append(buffer_, bytes_read);
-  } while (request_->Read(buffer_, sizeof(buffer_), &bytes_read));
+    data_.append(buffer_->data(), bytes_read);
+  } while (request_->Read(buffer_, kBufferSize, &bytes_read));
 
   if (request_->status().is_success())
     request_->GetResponseCookies(&cookies_);
 
   // See comments re: HEAD requests in OnResponseStarted().
   if (!request_->status().is_io_pending() || (request_type_ == HEAD)) {
     delegate_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &Core::OnCompletedURLRequest, request_->status()));
     delete request_;
     request_ = NULL;
@@ skipping 74 matching lines @@
                                       cookies_, data_);
       }
     }
   } else {
     protect_entry_->UpdateBackoff(URLFetcherProtectEntry::SUCCESS);
     if (delegate_)
       delegate_->OnURLFetchComplete(fetcher_, url_, status, response_code_,
                                     cookies_, data_);
   }
 }