| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/logging.h" | |
| 6 #include "net/base/io_buffer.h" | |
| 7 #include "net/base/net_errors.h" | |
| 8 #include "net/disk_cache/flash/cache_entry.h" | |
| 9 #include "net/disk_cache/flash/format.h" | |
| 10 #include "net/disk_cache/flash/log_structured_store.h" | |
| 11 | |
| 12 namespace disk_cache { | |
| 13 | |
| 14 CacheEntry::CacheEntry(LogStructuredStore* store) | |
| 15 : store_(store), id_(-1), init_(false), closed_(false) { | |
| 16 DCHECK(store); | |
| 17 } | |
| 18 | |
| 19 CacheEntry::CacheEntry(LogStructuredStore* store, int32 id) | |
| 20 : store_(store), id_(id), init_(false), closed_(false) { | |
| 21 DCHECK(store); | |
| 22 } | |
| 23 | |
| 24 CacheEntry::~CacheEntry() { | |
| 25 DCHECK(!init_ || closed_); | |
| 26 } | |
| 27 | |
| 28 bool CacheEntry::Init() { | |
| 29 DCHECK(!init_); | |
| 30 if (!OnDisk()) { | |
| 31 init_ = true; | |
| 32 return true; | |
| 33 } | |
| 34 | |
| 35 int32 stream_sizes[kFlashCacheEntryNumStreams]; | |
| 36 COMPILE_ASSERT(sizeof(stream_sizes) == kFlashCacheEntryHeaderSize, | |
| 37 invalid_cache_entry_header_size); | |
| 38 | |
| 39 if (!store_->OpenEntry(id_) || | |
| 40 !store_->ReadData(id_, stream_sizes, kFlashCacheEntryHeaderSize, 0)) { | |
| 41 return false; | |
| 42 } | |
| 43 for (int i = 0, offset = kFlashCacheEntryHeaderSize; | |
| 44 i < kFlashCacheEntryNumStreams; ++i) { | |
| 45 streams_[i].offset = offset; | |
| 46 streams_[i].size = stream_sizes[i]; | |
| 47 offset += stream_sizes[i]; | |
| 48 } | |
| 49 init_ = true; | |
| 50 return true; | |
| 51 } | |
| 52 | |
| 53 bool CacheEntry::Close() { | |
| 54 DCHECK(init_ && !closed_); | |
| 55 if (OnDisk()) | |
| 56 store_->CloseEntry(id_); | |
| 57 else if (!Save()) | |
| 58 return false; | |
| 59 closed_ = true; | |
| 60 return true; | |
| 61 } | |
| 62 | |
| 63 int32 CacheEntry::id() const { | |
| 64 DCHECK(init_); | |
| 65 return id_; | |
| 66 } | |
| 67 | |
| 68 int32 CacheEntry::GetDataSize(int index) const { | |
| 69 DCHECK(init_); | |
| 70 return InvalidStream(index) ? 0 : streams_[index].size; | |
| 71 } | |
| 72 | |
| 73 int CacheEntry::ReadData(int index, int offset, net::IOBuffer* buf, | |
| 74 int buf_len) { | |
| 75 DCHECK(init_); | |
| 76 if (InvalidStream(index)) | |
| 77 return net::ERR_INVALID_ARGUMENT; | |
| 78 | |
| 79 int stream_size = streams_[index].size; | |
| 80 if (offset >= stream_size || offset < 0 || buf_len == 0) | |
| 81 return 0; | |
| 82 if (offset + buf_len > stream_size) | |
| 83 buf_len = stream_size - offset; | |
| 84 | |
| 85 if (OnDisk()) { | |
| 86 offset += streams_[index].offset; | |
| 87 if (store_->ReadData(id_, buf->data(), buf_len, offset)) | |
| 88 return buf_len; | |
| 89 return net::ERR_FAILED; | |
| 90 } | |
| 91 memcpy(buf->data(), &streams_[index].write_buffer[offset], buf_len); | |
| 92 return buf_len; | |
| 93 } | |
| 94 | |
| 95 int CacheEntry::WriteData(int index, int offset, net::IOBuffer* buf, | |
| 96 int buf_len) { | |
| 97 DCHECK(init_ && !closed_); | |
| 98 if (InvalidStream(index)) | |
| 99 return net::ERR_INVALID_ARGUMENT; | |
| 100 | |
| 101 DCHECK(offset >= 0 && buf_len >= 0); | |
| 102 Stream& stream = streams_[index]; | |
| 103 size_t new_size = static_cast<size_t>(offset + buf_len); | |
| 104 if (new_size) { | |
| 105 // TODO(agayev): Currently, only append and overwrite is supported. Add | |
| 106 // support for arbitrary writes. | |
| 107 DCHECK(!offset || offset == stream.size); | |
| 108 if (stream.write_buffer.size() < new_size) | |
| 109 stream.write_buffer.resize(new_size); | |
| 110 memcpy(&streams_[index].write_buffer[offset], buf->data(), buf_len); | |
| 111 } | |
| 112 stream.size = new_size; | |
| 113 return buf_len; | |
| 114 } | |
| 115 | |
| 116 bool CacheEntry::OnDisk() const { | |
| 117 return id_ != -1; | |
| 118 } | |
| 119 | |
| 120 bool CacheEntry::InvalidStream(int stream_index) const { | |
| 121 return stream_index < 0 || stream_index >= kFlashCacheEntryNumStreams; | |
| 122 } | |
| 123 | |
| 124 int32 CacheEntry::Size() const { | |
| 125 DCHECK(init_); | |
| 126 int32 size = kFlashCacheEntryHeaderSize; | |
| 127 for (int i = 0; i < kFlashCacheEntryNumStreams; ++i) | |
| 128 size += streams_[i].size; | |
| 129 DCHECK(size > 0 && size <= kFlashSegmentFreeSpace); | |
| 130 return size; | |
| 131 } | |
| 132 | |
| 133 bool CacheEntry::Save() { | |
| 134 DCHECK(init_ && !closed_ && !OnDisk()); | |
| 135 int32 stream_sizes[kFlashCacheEntryNumStreams]; | |
| 136 COMPILE_ASSERT(sizeof(stream_sizes) == kFlashCacheEntryHeaderSize, | |
| 137 invalid_cache_entry_header_size); | |
| 138 | |
| 139 for (int i = 0; i < kFlashCacheEntryNumStreams; ++i) | |
| 140 stream_sizes[i] = streams_[i].size; | |
| 141 | |
| 142 if (!store_->CreateEntry(Size(), &id_)) | |
| 143 return false; | |
| 144 if (!store_->WriteData(stream_sizes, kFlashCacheEntryHeaderSize)) | |
| 145 return false; | |
| 146 for (int i = 0; i < kFlashCacheEntryNumStreams; ++i) { | |
| 147 if (streams_[i].size > 0 && | |
| 148 !store_->WriteData(&streams_[i].write_buffer[0], streams_[i].size)) { | |
| 149 return false; | |
| 150 } | |
| 151 } | |
| 152 store_->CloseEntry(id_); | |
| 153 return true; | |
| 154 } | |
| 155 | |
| 156 CacheEntry::Stream::Stream() : offset(0), size(0) { | |
| 157 } | |
| 158 | |
| 159 CacheEntry::Stream::~Stream() { | |
| 160 } | |
| 161 | |
| 162 } // namespace disk_cache | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 11532011:
Renamed classes for consistency. (Closed)
Base URL: http://git.chromium.org/chromium/src.git@master