Extend the IOBuffer to the disk cache....

net/disk_cache/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/entry_impl.h"
 
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
+#include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/cache_util.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace {
 
 // Index for the file used to store the key, if any (files_[kKeyFileIndex]).
 const int kKeyFileIndex = 3;
 
 // This class implements FileIOCallback to buffer the callback from a file IO
 // operation from the actual net class.
 class SyncCallback: public disk_cache::FileIOCallback {
  public:
-  SyncCallback(disk_cache::EntryImpl* entry,
+  SyncCallback(disk_cache::EntryImpl* entry, net::IOBuffer* buffer,
                net::CompletionCallback* callback )
-      : entry_(entry), callback_(callback) {
+      : entry_(entry), callback_(callback), buf_(buffer) {
     entry->AddRef();
     entry->IncrementIoCount();
   }
   ~SyncCallback() {}
 
   virtual void OnFileIOComplete(int bytes_copied);
   void Discard();
  private:
   disk_cache::EntryImpl* entry_;
   net::CompletionCallback* callback_;
+  scoped_refptr<net::IOBuffer> buf_;
 
   DISALLOW_EVIL_CONSTRUCTORS(SyncCallback);
 };
 
 void SyncCallback::OnFileIOComplete(int bytes_copied) {
   entry_->DecrementIoCount();
   entry_->Release();
   if (callback_)
     callback_->Run(bytes_copied);
   delete this;
 }
 
 void SyncCallback::Discard() {
   callback_ = NULL;
+  buf_ = NULL;
   OnFileIOComplete(0);
 }
 
 // Clears buffer before offset and after valid_len, knowing that the size of
 // buffer is kMaxBlockSize.
 void ClearInvalidData(char* buffer, int offset, int valid_len) {
   DCHECK(offset >= 0);
   DCHECK(valid_len >= 0);
   DCHECK(disk_cache::kMaxBlockSize >= offset + valid_len);
   if (offset)
@@ skipping 124 matching lines @@
 }
 
 int32 EntryImpl::GetDataSize(int index) const {
   if (index < 0 || index >= NUM_STREAMS)
     return 0;
 
   CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_);
   return entry->Data()->data_size[index];
 }
 
-int EntryImpl::ReadData(int index, int offset, char* buf, int buf_len,
+int EntryImpl::ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
                         net::CompletionCallback* completion_callback) {
   DCHECK(node_.Data()->dirty);
   if (index < 0 || index >= NUM_STREAMS)
     return net::ERR_INVALID_ARGUMENT;
 
   int entry_size = entry_.Data()->data_size[index];
   if (offset >= entry_size || offset < 0 || !buf_len)
     return 0;
 
   if (buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   Time start = Time::Now();
   static Histogram stats(L"DiskCache.ReadTime", TimeDelta::FromMilliseconds(1),
                          TimeDelta::FromSeconds(10), 50);
   stats.SetFlags(kUmaTargetedHistogramFlag);
 
   if (offset + buf_len > entry_size)
     buf_len = entry_size - offset;
 
   UpdateRank(false);
 
   backend_->OnEvent(Stats::READ_DATA);
 
   if (user_buffers_[index].get()) {
     // Complete the operation locally.
     DCHECK(kMaxBlockSize >= offset + buf_len);
-    memcpy(buf , user_buffers_[index].get() + offset, buf_len);
+    memcpy(buf->data() , user_buffers_[index].get() + offset, buf_len);
     stats.AddTime(Time::Now() - start);
     return buf_len;
   }
 
   Addr address(entry_.Data()->data_addr[index]);
   DCHECK(address.is_initialized());
   if (!address.is_initialized())
     return net::ERR_FAILED;
 
   File* file = GetBackingFile(address, index);
   if (!file)
     return net::ERR_FAILED;
 
   size_t file_offset = offset;
   if (address.is_block_file())
     file_offset += address.start_block() * address.BlockSize() +
                    kBlockHeaderSize;
 
   SyncCallback* io_callback = NULL;
   if (completion_callback)
-    io_callback = new SyncCallback(this, completion_callback);
+    io_callback = new SyncCallback(this, buf, completion_callback);
 
   bool completed;
-  if (!file->Read(buf, buf_len, file_offset, io_callback, &completed)) {
+  if (!file->Read(buf->data(), buf_len, file_offset, io_callback, &completed)) {
     if (io_callback)
       io_callback->Discard();
     return net::ERR_FAILED;
   }
 
   if (io_callback && completed)
     io_callback->Discard();
 
   stats.AddTime(Time::Now() - start);
   return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
 }
 
-int EntryImpl::WriteData(int index, int offset, const char* buf, int buf_len,
+int EntryImpl::WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
                          net::CompletionCallback* completion_callback,
                          bool truncate) {
   DCHECK(node_.Data()->dirty);
   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();
@@ skipping 37 matching lines @@
         truncate = false;
       }
   }
 
   UpdateRank(true);
 
   backend_->OnEvent(Stats::WRITE_DATA);
 
   if (user_buffers_[index].get()) {
     // Complete the operation locally.
+    if (!buf_len)
+      return 0;
+
     DCHECK(kMaxBlockSize >= offset + buf_len);
-    memcpy(user_buffers_[index].get() + offset, buf, buf_len);
+    memcpy(user_buffers_[index].get() + offset, buf->data(), buf_len);
     stats.AddTime(Time::Now() - start);
     return buf_len;
   }
 
   Addr address(entry_.Data()->data_addr[index]);
   File* file = GetBackingFile(address, index);
   if (!file)
     return net::ERR_FAILED;
 
   size_t file_offset = offset;
   if (address.is_block_file()) {
     file_offset += address.start_block() * address.BlockSize() +
                    kBlockHeaderSize;
   } else if (truncate) {
     if (!file->SetLength(offset + buf_len))
       return net::ERR_FAILED;
   }
 
   if (!buf_len)
     return 0;
 
   SyncCallback* io_callback = NULL;
   if (completion_callback)
-    io_callback = new SyncCallback(this, completion_callback);
+    io_callback = new SyncCallback(this, buf, completion_callback);
 
   bool completed;
-  if (!file->Write(buf, buf_len, file_offset, io_callback, &completed)) {
+  if (!file->Write(buf->data(), buf_len, file_offset, io_callback,
+                   &completed)) {
     if (io_callback)
       io_callback->Discard();
     return net::ERR_FAILED;
   }
 
   if (io_callback && completed)
     io_callback->Discard();
 
   stats.AddTime(Time::Now() - start);
   return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
@@ skipping 413 matching lines @@
         entry_.address().value(), node_.address().value());
 
   Trace("  data: 0x%x 0x%x 0x%x", entry_.Data()->data_addr[0],
         entry_.Data()->data_addr[1], entry_.Data()->long_key);
 
   Trace("  doomed: %d 0x%p 0x%x", doomed_, pointer, dirty);
 }
 
 }  // namespace disk_cache