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

net/http/http_cache.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_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
@@ skipping 172 matching lines @@
 
   // Clean up the transaction.
   virtual ~Transaction();
 
   // HttpTransaction methods:
   virtual int Start(const HttpRequestInfo*, CompletionCallback*);
   virtual int RestartIgnoringLastError(CompletionCallback*);
   virtual int RestartWithAuth(const std::wstring& username,
                               const std::wstring& password,
                               CompletionCallback* callback);
-  virtual int Read(char* buf, int buf_len, CompletionCallback*);
+  virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback*);
   virtual const HttpResponseInfo* GetResponseInfo() const;
   virtual LoadState GetLoadState() const;
   virtual uint64 GetUploadProgress(void) const;
 
   // The transaction has the following modes, which apply to how it may access
   // its cache entry.
   //
   //  o If the mode of the transaction is NONE, then it is in "pass through"
   //    mode and all methods just forward to the inner network transaction.
   //
@@ skipping 200 matching lines @@
   auth_response_ = HttpResponseInfo();
 
   int rv = RestartNetworkRequestWithAuth(username, password);
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
-int HttpCache::Transaction::Read(char* buf, int buf_len,
+int HttpCache::Transaction::Read(IOBuffer* buf, int buf_len,
                                  CompletionCallback* callback) {
   DCHECK(buf);
   DCHECK(buf_len > 0);
   DCHECK(callback);
 
   DCHECK(!callback_);
 
   // If we have an intermediate auth response at this point, then it means the
   // user wishes to read the network response (the error page).  If there is a
   // previous response in the cache then we should leave it intact.
   if (auth_response_.headers && mode_ != NONE) {
     DCHECK(mode_ & WRITE);
     DoneWritingToEntry(mode_ == READ_WRITE);
     mode_ = NONE;
   }
 
   int rv;
 
   switch (mode_) {
     case NONE:
     case WRITE:
       DCHECK(network_trans_.get());
       rv = network_trans_->Read(buf, buf_len, &network_read_callback_);
-      read_buf_ = buf;
+      read_buf_ = buf->data();
       if (rv >= 0)
         OnNetworkReadCompleted(rv);
       break;
     case READ:
       DCHECK(entry_);
-      cache_read_callback_->AddRef();  // Balanced in OnCacheReadCompleted
+      cache_read_callback_->AddRef();  // Balanced in OnCacheReadCompleted.
+      cache_read_callback_->UseBuffer(buf);
       rv = entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
-                                        buf, buf_len, cache_read_callback_);
-      read_buf_ = buf;
+                                        buf->data(), buf_len,
+                                        cache_read_callback_);
+      read_buf_ = buf->data();
       if (rv >= 0) {
         OnCacheReadCompleted(rv);
       } else if (rv != ERR_IO_PENDING) {
         cache_read_callback_->Release();
+        cache_read_callback_->ReleaseBuffer();
       }
       break;
     default:
       NOTREACHED();
       rv = ERR_FAILED;
   }
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
   return rv;
@@ skipping 434 matching lines @@
   if (result > 0) {
     AppendResponseDataToEntry(read_buf_, result);
   } else if (result == 0) {  // end of file
     DoneWritingToEntry(true);
   }
   HandleResult(result);
 }
 
 void HttpCache::Transaction::OnCacheReadCompleted(int result) {
   DCHECK(cache_);
-  cache_read_callback_->Release();  // Balance the AddRef() from Start()
+  cache_read_callback_->Release();  // Balance the AddRef() from Start().
+  cache_read_callback_->ReleaseBuffer();
 
   if (result > 0) {
     read_offset_ += result;
   } else if (result == 0) {  // end of file
     cache_->DoneReadingFromEntry(entry_, this);
     entry_ = NULL;
   }
   HandleResult(result);
 }
 
@@ skipping 454 matching lines @@
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
   AddTransactionToEntry(entry, next);
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net