diff options
| -rw-r--r-- | net/disk_cache/entry_unittest.cc | 128 | ||||
| -rw-r--r-- | net/disk_cache/mem_entry_impl.cc | 310 | ||||
| -rw-r--r-- | net/disk_cache/mem_entry_impl.h | 66 | ||||
| -rw-r--r-- | net/disk_cache/mem_rankings.cc | 5 | ||||
| -rw-r--r-- | net/disk_cache/mem_rankings.h | 2 |
5 files changed, 73 insertions, 438 deletions
diff --git a/net/disk_cache/entry_unittest.cc b/net/disk_cache/entry_unittest.cc index bf111ec..7b7d5d3 100644 --- a/net/disk_cache/entry_unittest.cc +++ b/net/disk_cache/entry_unittest.cc @@ -828,37 +828,43 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) { // enumerations. TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSlaveEntries) { SetMemoryOnlyMode(); + SetDirectMode(); + SetMaxSize(1024); InitCache(); - const int kSize = 4096; - scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); - CacheTestFillBuffer(buf->data(), kSize, false); - - std::string key("the first key"); - disk_cache::Entry* parent_entry; - ASSERT_TRUE(cache_->CreateEntry(key, &parent_entry)); - - // Writes to the parent entry. - EXPECT_EQ(kSize, parent_entry->WriteSparseData(0, buf, kSize, NULL)); - - // This write creates a child entry and writes to it. - EXPECT_EQ(kSize, parent_entry->WriteSparseData(8192, buf, kSize, NULL)); + disk_cache::Entry* entry; + disk_cache::MemEntryImpl* parent_entry; + ASSERT_TRUE(cache_->CreateEntry("parent", &entry)); + parent_entry = reinterpret_cast<disk_cache::MemEntryImpl*>(entry); + EXPECT_EQ(disk_cache::MemEntryImpl::kParentEntry, parent_entry->type()); parent_entry->Close(); + disk_cache::MemEntryImpl* child_entry = + new disk_cache::MemEntryImpl(mem_cache_); + // TODO(hclam): we shouldn't create a child entry explicit. Once a parent + // entry can be triggered to create a child entry, we should change this + // to use another public method to do the creation. + EXPECT_TRUE(child_entry->CreateChildEntry(parent_entry)); + EXPECT_EQ(disk_cache::MemEntryImpl::kChildEntry, child_entry->type()); + // Perform the enumerations. void* iter = NULL; - disk_cache::Entry* entry = NULL; int count = 0; while (cache_->OpenNextEntry(&iter, &entry)) { ASSERT_TRUE(entry != NULL); - ++count; disk_cache::MemEntryImpl* mem_entry = reinterpret_cast<disk_cache::MemEntryImpl*>(entry); EXPECT_EQ(disk_cache::MemEntryImpl::kParentEntry, mem_entry->type()); + EXPECT_TRUE(mem_entry == parent_entry); mem_entry->Close(); + ++count; } EXPECT_EQ(1, count); + + // TODO(hclam): remove this when parent entry can doom child entries + // internally. Now we have to doom this child entry manually. + child_entry->Doom(); } // Writes |buf_1| to offset and reads it back as |buf_2|. @@ -934,7 +940,7 @@ TEST_F(DiskCacheEntryTest, BasicSparseSyncIO) { BasicSparseIO(false); } -TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseSyncIO) { +TEST_F(DiskCacheEntryTest, DISABLED_MemoryOnlyBasicSparseSyncIO) { SetMemoryOnlyMode(); InitCache(); BasicSparseIO(false); @@ -945,7 +951,7 @@ TEST_F(DiskCacheEntryTest, BasicSparseAsyncIO) { BasicSparseIO(true); } -TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseAsyncIO) { +TEST_F(DiskCacheEntryTest, DISABLED_MemoryOnlyBasicSparseAsyncIO) { SetMemoryOnlyMode(); InitCache(); BasicSparseIO(true); @@ -977,7 +983,7 @@ TEST_F(DiskCacheEntryTest, HugeSparseSyncIO) { HugeSparseIO(false); } -TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseSyncIO) { +TEST_F(DiskCacheEntryTest, DISABLED_MemoryOnlyHugeSparseSyncIO) { SetMemoryOnlyMode(); InitCache(); HugeSparseIO(false); @@ -988,7 +994,7 @@ TEST_F(DiskCacheEntryTest, HugeSparseAsyncIO) { HugeSparseIO(true); } -TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseAsyncIO) { +TEST_F(DiskCacheEntryTest, DISABLED_MemoryOnlyHugeSparseAsyncIO) { SetMemoryOnlyMode(); InitCache(); HugeSparseIO(true); @@ -1041,90 +1047,8 @@ TEST_F(DiskCacheEntryTest, GetAvailableRange) { GetAvailableRange(); } -TEST_F(DiskCacheEntryTest, MemoryOnlyGetAvailableRange) { +TEST_F(DiskCacheEntryTest, DISABLED_MemoryOnlyGetAvailableRange) { SetMemoryOnlyMode(); InitCache(); GetAvailableRange(); } - -TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) { - SetMemoryOnlyMode(); - InitCache(); - - const int kSize = 8192; - scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(kSize); - scoped_refptr<net::IOBuffer> buf_2 = new net::IOBuffer(kSize); - CacheTestFillBuffer(buf_1->data(), kSize, false); - - std::string key("the first key"); - disk_cache::Entry* entry; - ASSERT_TRUE(cache_->CreateEntry(key, &entry)); - - // This loop writes back to back starting from offset 0 and 9000. - for (int i = 0; i < kSize; i += 1024) { - scoped_refptr<net::WrappedIOBuffer> buf_3 = - new net::WrappedIOBuffer(buf_1->data() + i); - VerifySparseIO(entry, i, buf_3, 1024, false, buf_2); - VerifySparseIO(entry, 9000 + i, buf_3, 1024, false, buf_2); - } - - // Make sure we have data written. - VerifyContentSparseIO(entry, 0, buf_1->data(), kSize, false); - VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize, false); - - // This tests a large write that spans 3 entries from a misaligned offset. - VerifySparseIO(entry, 20481, buf_1, 8192, false, buf_2); - - entry->Close(); -} - -TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) { - SetMemoryOnlyMode(); - InitCache(); - - const int kSize = 8192; - scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); - CacheTestFillBuffer(buf->data(), kSize, false); - - disk_cache::Entry* entry; - std::string key("the first key"); - ASSERT_TRUE(cache_->CreateEntry(key, &entry)); - - // Writes in the middle of an entry. - EXPECT_EQ(1024, entry->WriteSparseData(0, buf, 1024, NULL)); - EXPECT_EQ(1024, entry->WriteSparseData(5120, buf, 1024, NULL)); - EXPECT_EQ(1024, entry->WriteSparseData(10000, buf, 1024, NULL)); - - // Writes in the middle of an entry and spans 2 child entries. - EXPECT_EQ(8192, entry->WriteSparseData(50000, buf, 8192, NULL)); - - int64 start; - // Test that we stop at a discontinuous child at the second block. - EXPECT_EQ(1024, entry->GetAvailableRange(0, 10000, &start)); - EXPECT_EQ(0, start); - - // Test that number of bytes is reported correctly when we start from the - // middle of a filled region. - EXPECT_EQ(512, entry->GetAvailableRange(512, 10000, &start)); - EXPECT_EQ(512, start); - - // Test that we found bytes in the child of next block. - EXPECT_EQ(1024, entry->GetAvailableRange(1024, 10000, &start)); - EXPECT_EQ(5120, start); - - // Test that the desired length is respected. It starts within a filled - // region. - EXPECT_EQ(512, entry->GetAvailableRange(5500, 512, &start)); - EXPECT_EQ(5500, start); - - // Test that the desired length is respected. It starts before a filled - // region. - EXPECT_EQ(500, entry->GetAvailableRange(5000, 620, &start)); - EXPECT_EQ(5120, start); - - // Test that multiple blocks are scanned. - EXPECT_EQ(8192, entry->GetAvailableRange(40000, 20000, &start)); - EXPECT_EQ(50000, start); - - entry->Close(); -} diff --git a/net/disk_cache/mem_entry_impl.cc b/net/disk_cache/mem_entry_impl.cc index bf6359d..4905785 100644 --- a/net/disk_cache/mem_entry_impl.cc +++ b/net/disk_cache/mem_entry_impl.cc @@ -11,28 +11,6 @@ using base::Time; -namespace { - -const int kSparseData = 1; - -// Maximum size of a sparse entry is 2 to the power of this number. -const int kMaxSparseEntryBits = 12; - -// Sparse entry has maximum size of 4KB. -const int kMaxSparseEntrySize = 1 << kMaxSparseEntryBits; - -// Convert global offset to child index. -inline int ToChildIndex(int64 offset) { - return static_cast<int>(offset >> kMaxSparseEntryBits); -} - -// Convert global offset to offset in child entry. -inline int ToChildOffset(int64 offset) { - return static_cast<int>(offset & (kMaxSparseEntrySize - 1)); -} - -} // nemespace - namespace disk_cache { MemEntryImpl::MemEntryImpl(MemBackendImpl* backend) { @@ -40,8 +18,6 @@ MemEntryImpl::MemEntryImpl(MemBackendImpl* backend) { backend_ = backend; ref_count_ = 0; parent_ = NULL; - child_id_ = 0; - child_first_pos_ = 0; next_ = NULL; prev_ = NULL; for (int i = 0; i < NUM_STREAMS; i++) @@ -58,14 +34,25 @@ bool MemEntryImpl::CreateEntry(const std::string& key) { key_ = key; last_modified_ = Time::Now(); last_used_ = Time::Now(); + type_ = kParentEntry; Open(); backend_->ModifyStorageSize(0, static_cast<int32>(key.size())); return true; } +bool MemEntryImpl::CreateChildEntry(MemEntryImpl* parent) { + parent_ = parent; + last_modified_ = Time::Now(); + last_used_ = Time::Now(); + type_ = kChildEntry; + // Insert this to the backend's ranking list. + backend_->InsertIntoRankingList(this); + return true; +} + void MemEntryImpl::Close() { // Only a parent entry can be closed. - DCHECK(type() == kParentEntry); + DCHECK(type_ == kParentEntry); ref_count_--; DCHECK(ref_count_ >= 0); if (!ref_count_ && doomed_) @@ -74,16 +61,14 @@ void MemEntryImpl::Close() { void MemEntryImpl::Open() { // Only a parent entry can be opened. - // TODO(hclam): make sure it's correct to not apply the concept of ref - // counting to child entry. - DCHECK(type() == kParentEntry); + DCHECK(type_ == kParentEntry); ref_count_++; DCHECK(ref_count_ >= 0); DCHECK(!doomed_); } bool MemEntryImpl::InUse() { - if (type() == kParentEntry) { + if (type_ == kParentEntry) { return ref_count_ > 0; } else { // A child entry is always not in use. The consequence is that a child entry @@ -96,11 +81,11 @@ bool MemEntryImpl::InUse() { void MemEntryImpl::Doom() { if (doomed_) return; - if (type() == kParentEntry) { + if (type_ == kParentEntry) { // Perform internal doom from the backend if this is a parent entry. backend_->InternalDoomEntry(this); } else { - // Manually detach from the backend and perform internal doom. + // Manually detach from the parent entry and perform internal doom. backend_->RemoveFromRankingList(this); InternalDoom(); } @@ -109,23 +94,10 @@ void MemEntryImpl::Doom() { void MemEntryImpl::InternalDoom() { doomed_ = true; if (!ref_count_) { - if (type() == kParentEntry) { - // If this is a parent entry, we need to doom all the child entries. - if (children_.get()) { - EntryMap children; - children.swap(*children_); - for (EntryMap::iterator i = children.begin(); - i != children.end(); ++i) { - // Since a pointer to this object is also saved in the map, avoid - // dooming it. - if (i->second != this) - i->second->Doom(); - } - DCHECK(children_->size() == 0); - } + if (type_ == kParentEntry) { + // TODO(hclam): doom all child entries associated with this entry. } else { - // If this is a child entry, detach it from the parent. - parent_->DetachChild(child_id_); + // TODO(hclam): detach this child entry from the parent entry. } delete this; } @@ -133,7 +105,7 @@ void MemEntryImpl::InternalDoom() { std::string MemEntryImpl::GetKey() const { // A child entry doesn't have key so this method should not be called. - DCHECK(type() == kParentEntry); + DCHECK(type_ == kParentEntry); return key_; } @@ -148,12 +120,16 @@ Time MemEntryImpl::GetLastModified() const { int32 MemEntryImpl::GetDataSize(int index) const { if (index < 0 || index >= NUM_STREAMS) return 0; + + // TODO(hclam): handle the case when this is a parent entry and has associated + // child entries. return data_size_[index]; } int MemEntryImpl::ReadData(int index, int offset, net::IOBuffer* buf, int buf_len, net::CompletionCallback* completion_callback) { - DCHECK(type() == kParentEntry || index == kSparseData); + // This method can only be called with a parent entry. + DCHECK(type_ == kParentEntry); if (index < 0 || index >= NUM_STREAMS) return net::ERR_INVALID_ARGUMENT; @@ -176,7 +152,8 @@ int MemEntryImpl::ReadData(int index, int offset, net::IOBuffer* buf, int MemEntryImpl::WriteData(int index, int offset, net::IOBuffer* buf, int buf_len, net::CompletionCallback* completion_callback, bool truncate) { - DCHECK(type() == kParentEntry || index == kSparseData); + // This method can only be called with a parent entry. + DCHECK(type_ == kParentEntry); if (index < 0 || index >= NUM_STREAMS) return net::ERR_INVALID_ARGUMENT; @@ -189,6 +166,9 @@ int MemEntryImpl::WriteData(int index, int offset, net::IOBuffer* buf, // offset of buf_len could be negative numbers. if (offset > max_file_size || buf_len > max_file_size || offset + buf_len > max_file_size) { + int size = offset + buf_len; + if (size <= max_file_size) + size = kint32max; return net::ERR_FAILED; } @@ -218,160 +198,16 @@ int MemEntryImpl::WriteData(int index, int offset, net::IOBuffer* buf, int MemEntryImpl::ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len, net::CompletionCallback* completion_callback) { - DCHECK(type() == kParentEntry); - - if (!InitSparseInfo()) - return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; - - if (offset < 0 || buf_len < 0 || !buf_len) - return net::ERR_INVALID_ARGUMENT; - - // We will keep using this buffer and adjust the offset in this buffer. - scoped_refptr<net::ReusedIOBuffer> io_buf = new net::ReusedIOBuffer(buf, - buf_len); - - // Counts the number of bytes read. - int bytes_read = 0; - - // Iterate until we have read enough. - while (bytes_read < buf_len) { - MemEntryImpl* child = OpenChild(offset + bytes_read, false); - - // No child present for that offset. - if (!child) - break; - - // We then need to prepare the child offset and len. - int child_offset = ToChildOffset(offset + bytes_read); - - // If we are trying to read from a position that the child entry has no data - // we should stop. - if (child_offset < child->child_first_pos_) - break; - int ret = child->ReadData(kSparseData, child_offset, io_buf, - buf_len - bytes_read, NULL); - - // If we encounter an error in one entry, return immediately. - if (ret < 0) - return ret; - else if (ret == 0) - break; - - // Increment the counter by number of bytes read in the child entry. - bytes_read += ret; - // And also adjust the buffer's offset. - if (bytes_read < buf_len) - io_buf->SetOffset(bytes_read); - } - - UpdateRank(false); - - return bytes_read; + return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; } int MemEntryImpl::WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len, net::CompletionCallback* completion_callback) { - DCHECK(type() == kParentEntry); - - if (!InitSparseInfo()) - return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; - - if (offset < 0 || buf_len < 0) - return net::ERR_INVALID_ARGUMENT; - - scoped_refptr<net::ReusedIOBuffer> io_buf = new net::ReusedIOBuffer(buf, - buf_len); - // Counter for amount of bytes written. - int bytes_written = 0; - - // This loop walks through child entries continuously starting from |offset| - // and writes blocks of data (of maximum size kMaxSparseEntrySize) into each - // child entry until all |buf_len| bytes are written. The write operation can - // start in the middle of an entry. - while (bytes_written < buf_len) { - MemEntryImpl* child = OpenChild(offset + bytes_written, true); - int child_offset = ToChildOffset(offset + bytes_written); - - // Find the right amount to write, this evaluates the remaining bytes to - // write and remaining capacity of this child entry. - int write_len = std::min(buf_len - bytes_written, - kMaxSparseEntrySize - child_offset); - - // Keep a record of the last byte position (exclusive) in the child. - int data_size = child->GetDataSize(kSparseData); - - // Always writes to the child entry. This operation may overwrite data - // previously written. - // TODO(hclam): if there is data in the entry and this write is not - // continuous we may want to discard this write. - int ret = child->WriteData(kSparseData, child_offset, io_buf, write_len, - NULL, true); - if (ret < 0) - return ret; - else if (ret == 0) - break; - - // Keep a record of the first byte position in the child if the write was - // not aligned nor continuous. This is to enable witting to the middle - // of an entry and still keep track of data off the aligned edge. - if (data_size != child_offset) - child->child_first_pos_ = child_offset; - - // Increment the counter. - bytes_written += ret; - - // And adjust the offset in the IO buffer. - if (bytes_written < buf_len) - io_buf->SetOffset(bytes_written); - } - - UpdateRank(true); - - return bytes_written; + return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; } int MemEntryImpl::GetAvailableRange(int64 offset, int len, int64* start) { - DCHECK(type() == kParentEntry); - DCHECK(start); - - if (!InitSparseInfo()) - return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; - - if (offset < 0 || len < 0 || !start) - return net::ERR_INVALID_ARGUMENT; - - MemEntryImpl* current_child = NULL; - - // Find the first child and record the number of empty bytes. - int empty = FindNextChild(offset, len, ¤t_child); - if (current_child) { - *start = offset + empty; - len -= empty; - - // Counts the number of continuous bytes. - int continuous = 0; - - // This loop scan for continuous bytes. - while (len && current_child) { - // Number of bytes available in this child. - int data_size = current_child->GetDataSize(kSparseData) - - ToChildOffset(*start + continuous); - if (data_size > len) - data_size = len; - - // We have found more continuous bytes so increment the count. Also - // decrement the length we should scan. - continuous += data_size; - len -= data_size; - - // If the next child is discontinuous, break the loop. - if (FindNextChild(*start + continuous, len, ¤t_child)) - break; - } - return continuous; - } - *start = offset; - return 0; + return net::ERR_CACHE_OPERATION_NOT_SUPPORTED; } void MemEntryImpl::PrepareTarget(int index, int offset, int buf_len) { @@ -402,84 +238,4 @@ void MemEntryImpl::UpdateRank(bool modified) { backend_->UpdateRank(this); } -bool MemEntryImpl::InitSparseInfo() { - DCHECK(type() == kParentEntry); - - if (!children_.get()) { - // If we already have some data in sparse stream but we are being - // initialized as a sparse entry, we should fail. - if (GetDataSize(kSparseData)) - return false; - children_.reset(new EntryMap()); - - // The parent entry stores data for the first block, so save this object to - // index 0. - (*children_)[0] = this; - } - return true; -} - -bool MemEntryImpl::InitChildEntry(MemEntryImpl* parent, int child_id) { - DCHECK(!parent_); - DCHECK(!child_id_); - parent_ = parent; - child_id_ = child_id; - last_modified_ = Time::Now(); - last_used_ = Time::Now(); - // Insert this to the backend's ranking list. - backend_->InsertIntoRankingList(this); - return true; -} - -MemEntryImpl* MemEntryImpl::OpenChild(int64 offset, bool create) { - DCHECK(type() == kParentEntry); - int index = ToChildIndex(offset); - EntryMap::iterator i = children_->find(index); - if (i != children_->end()) { - return i->second; - } else if (create) { - MemEntryImpl* child = new MemEntryImpl(backend_); - child->InitChildEntry(this, index); - (*children_)[index] = child; - return child; - } - return NULL; -} - -int MemEntryImpl::FindNextChild(int64 offset, int len, MemEntryImpl** child) { - DCHECK(child); - *child = NULL; - int scanned_len = 0; - - // This loop tries to find the first existing child. - while (scanned_len < len) { - // This points to the current offset in the child. - int current_child_offset = ToChildOffset(offset + scanned_len); - MemEntryImpl* current_child = OpenChild(offset + scanned_len, false); - if (current_child) { - int child_first_pos = current_child->child_first_pos_; - - // This points to the first byte that we should be reading from, we need - // to take care of the filled region and the current offset in the child. - int first_pos = std::max(current_child_offset, child_first_pos); - - // If the first byte position we should read from doesn't exceed the - // filled region, we have found the first child. - if (first_pos < current_child->GetDataSize(kSparseData)) { - *child = current_child; - - // We need to advance the scanned length. - scanned_len += first_pos - current_child_offset; - break; - } - } - scanned_len += kMaxSparseEntrySize - current_child_offset; - } - return scanned_len; -} - -void MemEntryImpl::DetachChild(int child_id) { - children_->erase(child_id); -} - } // namespace disk_cache diff --git a/net/disk_cache/mem_entry_impl.h b/net/disk_cache/mem_entry_impl.h index 5f596bb..c63f928 100644 --- a/net/disk_cache/mem_entry_impl.h +++ b/net/disk_cache/mem_entry_impl.h @@ -5,8 +5,6 @@ #ifndef NET_DISK_CACHE_MEM_ENTRY_IMPL_H_ #define NET_DISK_CACHE_MEM_ENTRY_IMPL_H_ -#include "base/hash_tables.h" -#include "base/scoped_ptr.h" #include "net/disk_cache/disk_cache.h" #include "testing/gtest/include/gtest/gtest_prod.h" @@ -17,31 +15,17 @@ class MemBackendImpl; // This class implements the Entry interface for the memory-only cache. An // object of this class represents a single entry on the cache. We use two // types of entries, parent and child to support sparse caching. -// // A parent entry is non-sparse until a sparse method is invoked (i.e. // ReadSparseData, WriteSparseData, GetAvailableRange) when sparse information // is initialized. It then manages a list of child entries and delegates the // sparse API calls to the child entries. It creates and deletes child entries // and updates the list when needed. -// // A child entry is used to carry partial cache content, non-sparse methods like // ReadData and WriteData cannot be applied to them. The lifetime of a child // entry is managed by the parent entry that created it except that the entry // can be evicted independently. A child entry does not have a key and it is not // registered in the backend's entry map. It is registered in the backend's // ranking list to enable eviction of a partial content. -// -// A sparse entry has a fixed maximum size and can be partially filled. There -// can only be one continous filled region in a sparse entry, as illustrated by -// the following example: -// | xxx ooooo | -// x = unfilled region -// o = filled region -// It is guranteed that there is at most one unfilled region and one filled -// region, and the unfilled region (if there is one) is always before the filled -// region. The book keeping for filled region in a sparse entry is done by using -// the variable |child_first_pos_| (inclusive). - class MemEntryImpl : public Entry { public: enum EntryType { @@ -73,6 +57,12 @@ class MemEntryImpl : public Entry { // cache. bool CreateEntry(const std::string& key); + // Performs the initialization of a MemEntryImpl as a child entry. + // TODO(hclam): this method should be private. Leave this as public because + // this is the only way to create a child entry. Move this method to private + // once child entries are created by parent entry. + bool CreateChildEntry(MemEntryImpl* parent); + // Permanently destroys this entry. void InternalDoom(); @@ -96,15 +86,13 @@ class MemEntryImpl : public Entry { } EntryType type() const { - return parent_ ? kChildEntry : kParentEntry; + return type_; } private: - typedef base::hash_map<int, MemEntryImpl*> EntryMap; - - enum { - NUM_STREAMS = 3 - }; + enum { + NUM_STREAMS = 3 + }; ~MemEntryImpl(); @@ -114,47 +102,19 @@ class MemEntryImpl : public Entry { // Updates ranking information. void UpdateRank(bool modified); - // Initializes the children map and sparse info. This method is only called - // on a parent entry. - bool InitSparseInfo(); - - // Performs the initialization of a MemEntryImpl as a child entry. - // |parent| is the pointer to the parent entry. |child_id| is the ID of - // the new child. - bool InitChildEntry(MemEntryImpl* parent, int child_id); - - // Returns an entry responsible for |offset|. The returned entry can be a - // child entry or this entry itself if |offset| points to the first range. - // If such entry does not exist and |create| is true, a new child entry is - // created. - MemEntryImpl* OpenChild(int64 offset, bool create); - - // Finds the first child located within the range [|offset|, |offset + len|). - // Returns the number of bytes ahead of |offset| to reach the first available - // bytes in the entry. The first child found is output to |child|. - int FindNextChild(int64 offset, int len, MemEntryImpl** child); - - // Removes child indexed by |child_id| from the children map. - void DetachChild(int child_id); - std::string key_; std::vector<char> data_[NUM_STREAMS]; // User data. int32 data_size_[NUM_STREAMS]; int ref_count_; - MemEntryImpl* next_; // Pointers for the LRU list. + MemEntryImpl* next_; // Pointers for the LRU list. MemEntryImpl* prev_; - MemEntryImpl* parent_; // Pointer to the parent entry. - scoped_ptr<EntryMap> children_; - - int child_id_; // The ID of a child entry. - int child_first_pos_; // The position of the first byte in a child - // entry. - + MemEntryImpl* parent_; // Pointer to the parent entry. base::Time last_modified_; // LRU information. base::Time last_used_; MemBackendImpl* backend_; // Back pointer to the cache. bool doomed_; // True if this entry was removed from the cache. + EntryType type_; // The type of this entry. DISALLOW_EVIL_CONSTRUCTORS(MemEntryImpl); }; diff --git a/net/disk_cache/mem_rankings.cc b/net/disk_cache/mem_rankings.cc index d5f4a65..6ca1bf7 100644 --- a/net/disk_cache/mem_rankings.cc +++ b/net/disk_cache/mem_rankings.cc @@ -4,15 +4,10 @@ #include "net/disk_cache/mem_rankings.h" -#include "base/logging.h" #include "net/disk_cache/mem_entry_impl.h" namespace disk_cache { -MemRankings::~MemRankings() { - DCHECK(!head_ && !tail_); -} - void MemRankings::Insert(MemEntryImpl* node) { if (head_) head_->set_prev(node); diff --git a/net/disk_cache/mem_rankings.h b/net/disk_cache/mem_rankings.h index 680be4c..9dd1564 100644 --- a/net/disk_cache/mem_rankings.h +++ b/net/disk_cache/mem_rankings.h @@ -17,7 +17,7 @@ class MemEntryImpl; class MemRankings { public: MemRankings() : head_(NULL), tail_(NULL) {} - ~MemRankings(); + ~MemRankings() {} // Inserts a given entry at the head of the queue. void Insert(MemEntryImpl* node); |