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/format.h"
9 #include "net/disk_cache/flash/log_store.h"
10 #include "net/disk_cache/flash/log_store_entry.h"
11
12 namespace disk_cache {
13
LogStoreEntry(LogStore * store)14 LogStoreEntry::LogStoreEntry(LogStore* store)
15 : store_(store), id_(-1), init_(false), closed_(false), deleted_(false) {
16 DCHECK(store);
17 }
18
LogStoreEntry(LogStore * store,int32 id)19 LogStoreEntry::LogStoreEntry(LogStore* store, int32 id)
20 : store_(store), id_(id), init_(false), closed_(false), deleted_(false) {
21 DCHECK(store);
22 }
23
~LogStoreEntry()24 LogStoreEntry::~LogStoreEntry() {
25 DCHECK(!init_ || closed_);
26 }
27
Init()28 bool LogStoreEntry::Init() {
29 DCHECK(!init_);
30 if (IsNew()) {
31 init_ = true;
32 return true;
33 }
34
35 int32 stream_sizes[kFlashLogStoreEntryNumStreams];
36 COMPILE_ASSERT(sizeof(stream_sizes) == kFlashLogStoreEntryHeaderSize,
37 invalid_log_store_entry_header_size);
38
39 if (!store_->OpenEntry(id_) ||
40 !store_->ReadData(id_, stream_sizes, kFlashLogStoreEntryHeaderSize, 0)) {
41 return false;
42 }
43 for (int i = 0, offset = kFlashLogStoreEntryHeaderSize;
44 i < kFlashLogStoreEntryNumStreams; ++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
Close()53 bool LogStoreEntry::Close() {
54 DCHECK(init_ && !closed_);
55
56 if (IsNew()) {
57 closed_ = deleted_ ? true : Save();
58 } else {
59 store_->CloseEntry(id_);
60 if (deleted_)
61 store_->DeleteEntry(id_, Size());
62 closed_ = true;
63 }
64 return closed_;
65 }
66
id() const67 int32 LogStoreEntry::id() const {
68 DCHECK(init_);
69 return id_;
70 }
71
GetDataSize(int index) const72 int32 LogStoreEntry::GetDataSize(int index) const {
73 DCHECK(init_);
74 return InvalidStream(index) ? 0 : streams_[index].size;
75 }
76
ReadData(int index,int offset,net::IOBuffer * buf,int buf_len)77 int LogStoreEntry::ReadData(int index, int offset, net::IOBuffer* buf,
78 int buf_len) {
79 DCHECK(init_);
80 if (InvalidStream(index))
81 return net::ERR_INVALID_ARGUMENT;
82
83 int stream_size = streams_[index].size;
84 if (offset >= stream_size || offset < 0 || buf_len == 0)
85 return 0;
86 if (offset + buf_len > stream_size)
87 buf_len = stream_size - offset;
88
89 if (!IsNew()) {
90 offset += streams_[index].offset;
91 if (store_->ReadData(id_, buf->data(), buf_len, offset))
92 return buf_len;
93 return net::ERR_FAILED;
94 }
95 memcpy(buf->data(), &streams_[index].write_buffer[offset], buf_len);
96 return buf_len;
97 }
98
WriteData(int index,int offset,net::IOBuffer * buf,int buf_len)99 int LogStoreEntry::WriteData(int index, int offset, net::IOBuffer* buf,
100 int buf_len) {
101 DCHECK(init_ && !closed_);
102 if (InvalidStream(index))
103 return net::ERR_INVALID_ARGUMENT;
104
105 DCHECK(offset >= 0 && buf_len >= 0);
106 Stream& stream = streams_[index];
107 size_t new_size = static_cast<size_t>(offset + buf_len);
108 if (new_size) {
109 // TODO(agayev): Currently, only append and overwrite is supported. Add
110 // support for arbitrary writes.
111 DCHECK(!offset || offset == stream.size);
112 if (stream.write_buffer.size() < new_size)
113 stream.write_buffer.resize(new_size);
114 memcpy(&streams_[index].write_buffer[offset], buf->data(), buf_len);
115 }
116 stream.size = new_size;
117 return buf_len;
118 }
119
Delete()120 void LogStoreEntry::Delete() {
121 DCHECK(init_ && !closed_);
122 deleted_ = true;
123 }
124
IsNew() const125 bool LogStoreEntry::IsNew() const {
126 return id_ == -1;
127 }
128
InvalidStream(int stream_index) const129 bool LogStoreEntry::InvalidStream(int stream_index) const {
130 return stream_index < 0 || stream_index >= kFlashLogStoreEntryNumStreams;
131 }
132
Size() const133 int32 LogStoreEntry::Size() const {
134 DCHECK(init_);
135 int32 size = kFlashLogStoreEntryHeaderSize;
136 for (int i = 0; i < kFlashLogStoreEntryNumStreams; ++i)
137 size += streams_[i].size;
138 DCHECK(size > 0 && size <= kFlashSegmentFreeSpace);
139 return size;
140 }
141
Save()142 bool LogStoreEntry::Save() {
143 DCHECK(init_ && !closed_ && !deleted_ && IsNew());
144 int32 stream_sizes[kFlashLogStoreEntryNumStreams];
145 COMPILE_ASSERT(sizeof(stream_sizes) == kFlashLogStoreEntryHeaderSize,
146 invalid_log_store_entry_header_size);
147
148 for (int i = 0; i < kFlashLogStoreEntryNumStreams; ++i)
149 stream_sizes[i] = streams_[i].size;
150
151 if (!store_->CreateEntry(Size(), &id_))
152 return false;
153 if (!store_->WriteData(stream_sizes, kFlashLogStoreEntryHeaderSize))
154 return false;
155 for (int i = 0; i < kFlashLogStoreEntryNumStreams; ++i) {
156 if (streams_[i].size > 0 &&
157 !store_->WriteData(&streams_[i].write_buffer[0], streams_[i].size)) {
158 return false;
159 }
160 }
161 store_->CloseEntry(id_);
162 return true;
163 }
164
Stream()165 LogStoreEntry::Stream::Stream() : offset(0), size(0) {
166 }
167
~Stream()168 LogStoreEntry::Stream::~Stream() {
169 }
170
171 } // namespace disk_cache
172