Disk cache: First pass to add support for sparse entries....

net/disk_cache/entry_impl.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2006-2009 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/bitmap.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/histogram_macros.h"
+#include "net/disk_cache/sparse_control.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
@@ skipping 59 matching lines @@
   }
 }
 
 // When an entry is deleted from the cache, we clean up all the data associated
 // with it for two reasons: to simplify the reuse of the block (we know that any
 // unused block is filled with zeros), and to simplify the handling of write /
 // read partial information from an entry (don't have to worry about returning
 // data related to a previous cache entry because the range was not fully
 // written before).
 EntryImpl::~EntryImpl() {
+  // Save the sparse info to disk before deleting this entry.
+  sparse_.reset();
+
   if (doomed_) {
     DeleteEntryData(true);
   } else {
     bool ret = true;
     for (int index = 0; index < NUM_STREAMS; index++) {
       if (user_buffers_[index].get()) {
         if (!(ret = Flush(index, entry_.Data()->data_size[index], false)))
           LOG(ERROR) << "Failed to save user data";
       } else if (unreported_size_[index]) {
         backend_->ModifyStorageSize(
@@ skipping 242 matching lines @@
   if (io_callback && completed)
     io_callback->Discard();
 
   if (backend_->cache_type() == net::DISK_CACHE)
     stats.AddTime(Time::Now() - start);
   return (completed || !completion_callback) ? buf_len : net::ERR_IO_PENDING;
 }
 
 int EntryImpl::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
                               net::CompletionCallback* completion_callback) {
-  return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
+  DCHECK(node_.Data()->dirty);
+  int result = InitSparseData();
+  if (net::OK != result)
+    return result;
+
+  return sparse_->StartIO(SparseControl::kReadOperation, offset, buf, buf_len,
+                          completion_callback);
 }
 
 int EntryImpl::WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
                                net::CompletionCallback* completion_callback) {
-  return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
+  DCHECK(node_.Data()->dirty);
+  int result = InitSparseData();
+  if (net::OK != result)
+    return result;
+
+  return sparse_->StartIO(SparseControl::kWriteOperation, offset, buf, buf_len,
+                          completion_callback);
 }
 
 int EntryImpl::GetAvailableRange(int64 offset, int len, int64* start) {
-  return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
+  int result = InitSparseData();
+  if (net::OK != result)
+    return result;
+
+  return sparse_->GetAvailableRange(offset, len, start);
 }
 
 uint32 EntryImpl::GetHash() {
   return entry_.Data()->hash;
 }
 
 bool EntryImpl::CreateEntry(Addr node_address, const std::string& key,
                             uint32 hash) {
   Trace("Create entry In");
   EntryStore* entry_store = entry_.Data();
@@ skipping 430 matching lines @@
       return false;
     user_buffers_[index].reset(NULL);
   }
 
   // The buffer is deleted from the PostWrite operation.
   user_buffers_[index].release();
 
   return true;
 }
 
+int EntryImpl::InitSparseData() {
+  if (sparse_.get())
+    return net::OK;
+
+  sparse_.reset(new SparseControl(this));
+  int result = sparse_->Init();
+  if (net::OK != result)
+    sparse_.reset();
+  return result;
+}
+
 void EntryImpl::Log(const char* msg) {
   void* pointer = NULL;
   int dirty = 0;
   if (node_.HasData()) {
     pointer = node_.Data()->pointer;
     dirty = node_.Data()->dirty;
   }
 
   Trace("%s 0x%p 0x%x 0x%x", msg, reinterpret_cast<void*>(this),
         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