Extend the IOBuffer to the disk cache.

net/disk_cache/mem_entry_impl.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/disk_cache/mem_entry_impl.h"
 
+#include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/mem_backend_impl.h"
 
 using base::Time;
 
 namespace disk_cache {
 
 MemEntryImpl::MemEntryImpl(MemBackendImpl* backend) {
   doomed_ = false;
   backend_ = backend;
@@ skipping 58 matching lines @@
   return last_modified_;
 }
 
 int32 MemEntryImpl::GetDataSize(int index) const {
   if (index < 0 || index >= NUM_STREAMS)
     return 0;
 
   return data_size_[index];
 }
 
-int MemEntryImpl::ReadData(int index, int offset, char* buf, int buf_len,
-                           net::CompletionCallback* completion_callback) {
+int MemEntryImpl::ReadData(int index, int offset, net::IOBuffer* buf,
+    int buf_len, net::CompletionCallback* completion_callback) {
   if (index < 0 || index >= NUM_STREAMS)
     return net::ERR_INVALID_ARGUMENT;
 
   int entry_size = GetDataSize(index);
   if (offset >= entry_size || offset < 0 || !buf_len)
     return 0;
 
   if (buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset + buf_len > entry_size)
     buf_len = entry_size - offset;
 
   UpdateRank(false);
 
-  memcpy(buf , &(data_[index])[offset], buf_len);
+  memcpy(buf->data() , &(data_[index])[offset], buf_len);
   return buf_len;
 }
 
-int MemEntryImpl::WriteData(int index, int offset, const char* buf, int buf_len,
-                         net::CompletionCallback* completion_callback,
-                         bool truncate) {
+int MemEntryImpl::WriteData(int index, int offset, net::IOBuffer* buf,
+    int buf_len, net::CompletionCallback* completion_callback, bool truncate) {
   if (index < 0 || index >= NUM_STREAMS)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   int max_file_size = backend_->MaxFileSize();
 
   // offset of buf_len could be negative numbers.
   if (offset > max_file_size || buf_len > max_file_size ||
@@ skipping 17 matching lines @@
       backend_->ModifyStorageSize(entry_size, offset + buf_len);
       data_size_[index] = offset + buf_len;
     }
   }
 
   UpdateRank(true);
 
   if (!buf_len)
     return 0;
 
-  memcpy(&(data_[index])[offset], buf, buf_len);
+  memcpy(&(data_[index])[offset], buf->data(), buf_len);
   return buf_len;
 }
 
 void MemEntryImpl::PrepareTarget(int index, int offset, int buf_len) {
   int entry_size = GetDataSize(index);
 
   if (entry_size >= offset + buf_len)
     return;  // Not growing the stored data.
 
   if (static_cast<int>(data_[index].size()) < offset + buf_len)
@@ skipping 13 matching lines @@
 
   if (modified)
     last_modified_ = current;
 
   if (!doomed_)
     backend_->UpdateRank(this);
 }
 
 }  // namespace disk_cache