Disk cache: Add explicit support for eviction / deletion...

net/disk_cache/entry_impl.cc

 // 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"
@@ skipping 435 matching lines @@
   if (!node_.Data()->dirty) {
     node_.Data()->dirty = backend_->GetCurrentEntryId();
     node_.Store();
   }
   doomed_ = true;
 }
 
 void EntryImpl::DeleteEntryData(bool everything) {
   DCHECK(doomed_ || !everything);
 
+  if (GetEntryFlags() & PARENT_ENTRY) {
+    // We have some child entries that must go away.
+    SparseControl::DeleteChildren(this);
+  }
+
   if (GetDataSize(0))
     CACHE_UMA(COUNTS, "DeleteHeader", 0, GetDataSize(0));
   if (GetDataSize(1))
     CACHE_UMA(COUNTS, "DeleteData", 0, GetDataSize(1));
   for (int index = 0; index < kNumStreams; index++) {
     Addr address(entry_.Data()->data_addr[index]);
     if (address.is_initialized()) {
       DeleteData(address, index);
       backend_->ModifyStorageSize(entry_.Data()->data_size[index] -
                                       unreported_size_[index], 0);
@@ skipping 361 matching lines @@
   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::SetEntryFlags(uint32 flags) {
+  entry_.Data()->flags |= flags;
+  entry_.set_modified();
+}
+
+uint32 EntryImpl::GetEntryFlags() {
+  return entry_.Data()->flags;
+}
+
+void EntryImpl::GetData(int index, char** buffer, Addr* address) {
+  if (user_buffers_[index].get()) {
+    // The data is already in memory, just copy it an we're done.
+    int data_len = entry_.Data()->data_size[index];
+    DCHECK(data_len <= kMaxBlockSize);
+    *buffer = new char[data_len];
+    memcpy(*buffer, user_buffers_[index].get(), data_len);
+    return;
+  }
+
+  // Bad news: we'd have to read the info from disk so instead we'll just tell
+  // the caller where to read from.
+  *buffer = NULL;
+  address->set_value(entry_.Data()->data_addr[index]);
+  if (address->is_initialized()) {
+    // Prevent us from deleting the block from the backing store.
+    backend_->ModifyStorageSize(entry_.Data()->data_size[index] -
+                                    unreported_size_[index], 0);
+    entry_.Data()->data_addr[index] = 0;
+    entry_.Data()->data_size[index] = 0;
+  }
+}
+
 void EntryImpl::ReportIOTime(Operation op, const base::Time& start) {
   int group = backend_->GetSizeGroup();
   switch (op) {
     case kRead:
       CACHE_UMA(AGE_MS, "ReadTime", group, start);
       break;
     case kWrite:
       CACHE_UMA(AGE_MS, "WriteTime", group, start);
       break;
     case kSparseRead:
@@ skipping 18 matching lines @@
   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