revert r8603

Review URL: http://codereview.chromium.org/18576

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@8605 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 25 insertions, 34 deletions

diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc
index fe0a130..7edc0a8 100644
--- a/net/http/http_cache.cc
+++ b/net/http/http_cache.cc
@@ -190,7 +190,7 @@ class HttpCache::Transaction : public HttpTransaction {
   virtual int RestartWithAuth(const std::wstring& username,
                               const std::wstring& password,
                               CompletionCallback* callback);
-  virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback*);
+  virtual int Read(char* buf, int buf_len, CompletionCallback*);
   virtual const HttpResponseInfo* GetResponseInfo() const;
   virtual LoadState GetLoadState() const;
   virtual uint64 GetUploadProgress(void) const;
@@ -411,7 +411,7 @@ int HttpCache::Transaction::RestartWithAuth(
   return rv;
 }
 
-int HttpCache::Transaction::Read(IOBuffer* buf, int buf_len,
+int HttpCache::Transaction::Read(char* buf, int buf_len,
                                  CompletionCallback* callback) {
   DCHECK(buf);
   DCHECK(buf_len > 0);
@@ -435,23 +435,20 @@ int HttpCache::Transaction::Read(IOBuffer* buf, int buf_len,
     case WRITE:
       DCHECK(network_trans_.get());
       rv = network_trans_->Read(buf, buf_len, &network_read_callback_);
-      read_buf_ = buf->data();
+      read_buf_ = buf;
       if (rv >= 0)
         OnNetworkReadCompleted(rv);
       break;
     case READ:
       DCHECK(entry_);
-      cache_read_callback_->AddRef();  // Balanced in OnCacheReadCompleted.
-      cache_read_callback_->UseBuffer(buf);
+      cache_read_callback_->AddRef();  // Balanced in OnCacheReadCompleted
       rv = entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
-                                        buf->data(), buf_len,
-                                        cache_read_callback_);
-      read_buf_ = buf->data();
+                                        buf, buf_len, cache_read_callback_);
+      read_buf_ = buf;
       if (rv >= 0) {
         OnCacheReadCompleted(rv);
       } else if (rv != ERR_IO_PENDING) {
         cache_read_callback_->Release();
-        cache_read_callback_->ReleaseBuffer();
       }
       break;
     default:
@@ -906,8 +903,7 @@ void HttpCache::Transaction::OnNetworkReadCompleted(int result) {
 
 void HttpCache::Transaction::OnCacheReadCompleted(int result) {
   DCHECK(cache_);
-  cache_read_callback_->Release();  // Balance the AddRef() from Start().
-  cache_read_callback_->ReleaseBuffer();
+  cache_read_callback_->Release();  // Balance the AddRef() from Start()
 
   if (result > 0) {
     read_offset_ += result;
diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc
index 0a71854..be6986e 100644
--- a/net/http/http_cache_unittest.cc
+++ b/net/http/http_cache_unittest.cc
@@ -676,8 +676,8 @@ TEST(HttpCache, SimpleGET_AbandonedCacheRead) {
     rv = callback.WaitForResult();
   ASSERT_EQ(net::OK, rv);
 
-  scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(256);
-  rv = trans->Read(buf, 256, &callback);
+  char buf[256];
+  rv = trans->Read(buf, sizeof(buf), &callback);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   // Test that destroying the transaction while it is reading from the cache
diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index 2e96deb..9d6ed1b 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -52,6 +52,7 @@ HttpNetworkTransaction::HttpNetworkTransaction(HttpNetworkSession* session,
       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)
@@ -133,7 +134,7 @@ void HttpNetworkTransaction::PrepareForAuthRestart(HttpAuth::Target target) {
   ResetStateForRestart();
 }
 
-int HttpNetworkTransaction::Read(IOBuffer* buf, int buf_len,
+int HttpNetworkTransaction::Read(char* buf, int buf_len,
                                  CompletionCallback* callback) {
   DCHECK(response_.headers);
   DCHECK(buf);
@@ -725,7 +726,7 @@ int HttpNetworkTransaction::DoReadBody() {
   // 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_->data(), header_buf_.get() + header_buf_body_offset_, n);
+    memcpy(read_buf_, header_buf_.get() + header_buf_body_offset_, n);
     header_buf_body_offset_ += n;
     if (header_buf_body_offset_ == header_buf_len_) {
       header_buf_.reset();
@@ -736,8 +737,7 @@ int HttpNetworkTransaction::DoReadBody() {
     return n;
   }
 
-  return connection_.socket()->Read(read_buf_->data(), read_buf_len_,
-                                    &io_callback_);
+  return connection_.socket()->Read(read_buf_, read_buf_len_, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoReadBodyComplete(int result) {
@@ -747,7 +747,7 @@ int HttpNetworkTransaction::DoReadBodyComplete(int result) {
 
   // Filter incoming data if appropriate.  FilterBuf may return an error.
   if (result > 0 && chunked_decoder_.get()) {
-    result = chunked_decoder_->FilterBuf(read_buf_->data(), result);
+    result = chunked_decoder_->FilterBuf(read_buf_, 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.
diff --git a/net/http/http_network_transaction.h b/net/http/http_network_transaction.h
index 9a4c619..487ddd3 100644
--- a/net/http/http_network_transaction.h
+++ b/net/http/http_network_transaction.h
@@ -39,7 +39,7 @@ class HttpNetworkTransaction : public HttpTransaction {
   virtual int RestartWithAuth(const std::wstring& username,
                               const std::wstring& password,
                               CompletionCallback* callback);
-  virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback);
+  virtual int Read(char* buf, int buf_len, CompletionCallback* callback);
   virtual const HttpResponseInfo* GetResponseInfo() const;
   virtual LoadState GetLoadState() const;
   virtual uint64 GetUploadProgress() const;
@@ -259,7 +259,7 @@ class HttpNetworkTransaction : public HttpTransaction {
   scoped_ptr<HttpChunkedDecoder> chunked_decoder_;
 
   // User buffer and length passed to the Read method.
-  scoped_refptr<IOBuffer> read_buf_;
+  char* read_buf_;
   int read_buf_len_;
 
   enum State {
diff --git a/net/http/http_transaction.h b/net/http/http_transaction.h
index 46c7671..ba2cf29 100644
--- a/net/http/http_transaction.h
+++ b/net/http/http_transaction.h
@@ -66,11 +66,8 @@ class HttpTransaction {
   // could not be read.
   //
   // NOTE: The transaction is not responsible for deleting the callback object.
-  // If the operation is not completed immediately, the transaction must acquire
-  // a reference to the provided buffer.
   //
-  virtual int Read(IOBuffer* buf, int buf_len,
-                   CompletionCallback* callback) = 0;
+  virtual int Read(char* buf, int buf_len, CompletionCallback* callback) = 0;
 
   // Returns the response info for this transaction or NULL if the response
   // info is not available.
diff --git a/net/http/http_transaction_unittest.cc b/net/http/http_transaction_unittest.cc
index e22c398..fdcceff 100644
--- a/net/http/http_transaction_unittest.cc
+++ b/net/http/http_transaction_unittest.cc
@@ -137,12 +137,12 @@ int ReadTransaction(net::HttpTransaction* trans, std::string* result) {
 
   std::string content;
   do {
-    scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(256);
-    rv = trans->Read(buf, 256, &callback);
+    char buf[256];
+    rv = trans->Read(buf, sizeof(buf), &callback);
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv > 0) {
-      content.append(buf->data(), rv);
+      content.append(buf, rv);
     } else if (rv < 0) {
       return rv;
     }
diff --git a/net/http/http_transaction_unittest.h b/net/http/http_transaction_unittest.h
index 0c26178..ccdb954 100644
--- a/net/http/http_transaction_unittest.h
+++ b/net/http/http_transaction_unittest.h
@@ -149,7 +149,7 @@ class TestTransactionConsumer : public CallbackRunner< Tuple1<int> > {
     if (result <= 0) {
       DidFinish(result);
     } else {
-      content_.append(read_buf_->data(), result);
+      content_.append(read_buf_, result);
       Read();
     }
   }
@@ -163,8 +163,7 @@ class TestTransactionConsumer : public CallbackRunner< Tuple1<int> > {
 
   void Read() {
     state_ = READING;
-    read_buf_ = new net::IOBuffer(1024);
-    int result = trans_->Read(read_buf_, 1024, this);
+    int result = trans_->Read(read_buf_, sizeof(read_buf_), this);
     if (result != net::ERR_IO_PENDING)
       DidRead(result);
   }
@@ -178,7 +177,7 @@ class TestTransactionConsumer : public CallbackRunner< Tuple1<int> > {
 
   scoped_ptr<net::HttpTransaction> trans_;
   std::string content_;
-  scoped_refptr<net::IOBuffer> read_buf_;
+  char read_buf_[1024];
   int error_;
 
   static int quit_counter_;
@@ -238,12 +237,11 @@ class MockNetworkTransaction : public net::HttpTransaction {
     return net::ERR_FAILED;
   }
 
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::CompletionCallback* callback) {
+  virtual int Read(char* buf, int buf_len, net::CompletionCallback* callback) {
     int data_len = static_cast<int>(data_.size());
     int num = std::min(buf_len, data_len - data_cursor_);
     if (num) {
-      memcpy(buf->data(), data_.data() + data_cursor_, num);
+      memcpy(buf, data_.data() + data_cursor_, num);
       data_cursor_ += num;
     }
     if (test_mode_ & TEST_MODE_SYNC_NET_READ)