Extend the IOBuffer to the disk cache.

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"
 #include "base/pickle.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "base/time.h"
+#include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_util.h"
 
 using base::Time;
@@ skipping 136 matching lines @@
 
 class HttpCache::Transaction : public HttpTransaction {
  public:
   explicit Transaction(HttpCache* cache)
       : request_(NULL),
         cache_(cache),
         entry_(NULL),
         network_trans_(NULL),
         callback_(NULL),
         mode_(NONE),
-        read_buf_(NULL),
         read_offset_(0),
         effective_load_flags_(0),
         final_upload_progress_(0),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             network_info_callback_(this, &Transaction::OnNetworkInfoAvailable)),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             network_read_callback_(this, &Transaction::OnNetworkReadCompleted)),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             cache_read_callback_(new CancelableCompletionCallback<Transaction>(
                 this, &Transaction::OnCacheReadCompleted))) {
@@ skipping 89 matching lines @@
   // Called to make the request conditional (to ask the server if the cached
   // copy is valid).  Returns true if able to make the request conditional.
   bool ConditionalizeRequest();
 
   // Called to populate response_ from the cache entry.
   int ReadResponseInfoFromEntry();
 
   // Called to write data to the cache entry.  If the write fails, then the
   // cache entry is destroyed.  Future calls to this function will just do
   // nothing without side-effect.
-  void WriteToEntry(int index, int offset, const char* data, int data_len);
+  void WriteToEntry(int index, int offset, IOBuffer* data, int data_len);
 
   // Called to write response_ to the cache entry.
   void WriteResponseInfoToEntry();
 
   // Called to append response data to the cache entry.
-  void AppendResponseDataToEntry(const char* data, int data_len);
+  void AppendResponseDataToEntry(IOBuffer* data, int data_len);
 
   // Called when we are done writing to the cache entry.
   void DoneWritingToEntry(bool success);
 
   // Called to signal completion of the network transaction's Start method:
   void OnNetworkInfoAvailable(int result);
 
   // Called to signal completion of the network transaction's Read method:
   void OnNetworkReadCompleted(int result);
 
   // Called to signal completion of the cache's ReadData method:
   void OnCacheReadCompleted(int result);
 
   const HttpRequestInfo* request_;
   scoped_ptr<HttpRequestInfo> custom_request_;
   HttpCache* cache_;
   HttpCache::ActiveEntry* entry_;
   scoped_ptr<HttpTransaction> network_trans_;
   CompletionCallback* callback_;  // consumer's callback
   HttpResponseInfo response_;
   HttpResponseInfo auth_response_;
   std::string cache_key_;
   Mode mode_;
-  char* read_buf_;
+  scoped_refptr<IOBuffer> read_buf_;
   int read_offset_;
   int effective_load_flags_;
   uint64 final_upload_progress_;
   CompletionCallbackImpl<Transaction> network_info_callback_;
   CompletionCallbackImpl<Transaction> network_read_callback_;
   scoped_refptr<CancelableCompletionCallback<Transaction> > cache_read_callback_;
 };
 
 HttpCache::Transaction::~Transaction() {
   if (entry_) {
@@ skipping 106 matching lines @@
     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->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);
       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:
       NOTREACHED();
       rv = ERR_FAILED;
   }
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
   return rv;
@@ skipping 305 matching lines @@
 int HttpCache::Transaction::ReadResponseInfoFromEntry() {
   DCHECK(entry_);
 
   if (!HttpCache::ReadResponseInfo(entry_->disk_entry, &response_))
     return ERR_FAILED;
 
   return OK;
 }
 
 void HttpCache::Transaction::WriteToEntry(int index, int offset,
-                                          const char* data, int data_len) {
+                                          IOBuffer* data, int data_len) {
   if (!entry_)
     return;
 
   int rv = entry_->disk_entry->WriteData(index, offset, data, data_len, NULL,
                                          true);
   if (rv != data_len) {
     DLOG(ERROR) << "failed to write response data to cache";
     DoneWritingToEntry(false);
   }
 }
@@ skipping 22 matching lines @@
   // headers; when in record mode, record everything.
   bool skip_transient_headers = (cache_->mode() != RECORD);
 
   if (!HttpCache::WriteResponseInfo(entry_->disk_entry, &response_,
                                     skip_transient_headers)) {
     DLOG(ERROR) << "failed to write response info to cache";
     DoneWritingToEntry(false);
   }
 }
 
-void HttpCache::Transaction::AppendResponseDataToEntry(const char* data,
+void HttpCache::Transaction::AppendResponseDataToEntry(IOBuffer* data,
                                                        int data_len) {
   if (!entry_)
     return;
 
   int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex);
   WriteToEntry(kResponseContentIndex, current_size, data, data_len);
 }
 
 void HttpCache::Transaction::DoneWritingToEntry(bool success) {
   if (!entry_)
@@ skipping 68 matching lines @@
     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_->ReleaseBuffer();
 
   if (result > 0) {
     read_offset_ += result;
   } else if (result == 0) {  // end of file
     cache_->DoneReadingFromEntry(entry_, this);
     entry_ = NULL;
   }
   HandleResult(result);
 }
 
@@ skipping 71 matching lines @@
 
 void HttpCache::Suspend(bool suspend) {
   network_layer_->Suspend(suspend);
 }
 
 // static
 bool HttpCache::ReadResponseInfo(disk_cache::Entry* disk_entry,
                                  HttpResponseInfo* response_info) {
   int size = disk_entry->GetDataSize(kResponseInfoIndex);
 
-  std::string data;
-  int rv = disk_entry->ReadData(kResponseInfoIndex, 0,
-                                WriteInto(&data, size + 1),
-                                size, NULL);
+  scoped_refptr<IOBuffer> buffer = new IOBuffer(size);
+  int rv = disk_entry->ReadData(kResponseInfoIndex, 0, buffer, size, NULL);
   if (rv != size) {
     DLOG(ERROR) << "ReadData failed: " << rv;
     return false;
   }
 
-  Pickle pickle(data.data(), static_cast<int>(data.size()));
+  Pickle pickle(buffer->data(), size);
   void* iter = NULL;
 
   // read flags and verify version
   int flags;
   if (!pickle.ReadInt(&iter, &flags))
     return false;
   int version = flags & RESPONSE_INFO_VERSION_MASK;
   if (version != RESPONSE_INFO_VERSION) {
     DLOG(ERROR) << "unexpected response info version: " << version;
     return false;
@@ skipping 77 matching lines @@
   if (response_info->ssl_info.cert) {
     response_info->ssl_info.cert->Persist(&pickle);
     pickle.WriteInt(response_info->ssl_info.cert_status);
   }
   if (response_info->ssl_info.security_bits != -1)
     pickle.WriteInt(response_info->ssl_info.security_bits);
 
   if (response_info->vary_data.is_valid())
     response_info->vary_data.Persist(&pickle);
 
-  const char* data = static_cast<const char*>(pickle.data());
+  scoped_refptr<WrappedIOBuffer> data = new WrappedIOBuffer(
+      reinterpret_cast<const char*>(pickle.data()));
   int len = static_cast<int>(pickle.size());
 
   return disk_entry->WriteData(kResponseInfoIndex, 0, data, len, NULL,
                                true) == len;
 }
 
 void HttpCache::DoomEntry(const std::string& key) {
   // Need to abandon the ActiveEntry, but any transaction attached to the entry
   // should not be impacted.  Dooming an entry only means that it will no
   // longer be returned by FindActiveEntry (and it will also be destroyed once
@@ skipping 255 matching lines @@
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
   AddTransactionToEntry(entry, next);
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net