Added CacheEntry implementation.

net/disk_cache/flash/cache_entry.cc

Index: net/disk_cache/flash/cache_entry.cc
diff --git a/net/disk_cache/flash/cache_entry.cc b/net/disk_cache/flash/cache_entry.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0ca8d986788ae37c21cda197bb71baef3f0e9de5
--- /dev/null
+++ b/net/disk_cache/flash/cache_entry.cc
@@ -0,0 +1,154 @@
+// Copyright (c) 2012 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 "base/logging.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/disk_cache/flash/cache_entry.h"
+#include "net/disk_cache/flash/format.h"
+#include "net/disk_cache/flash/log_structured_store.h"
+
+namespace disk_cache {
+
+CacheEntry::CacheEntry(LogStructuredStore* store)
+    : store_(store), id_(-1), init_(false), closed_(false) {
+  DCHECK(store);
+}
+
+CacheEntry::CacheEntry(LogStructuredStore* store, int32 id)
+    : store_(store), id_(id), init_(false), closed_(false) {
+  DCHECK(store);
+}
+
+CacheEntry::~CacheEntry() {
+  DCHECK(!init_ || closed_);
+}
+
+bool CacheEntry::Init() {
+  DCHECK(!init_);
+  if (!OnDisk()) {
+    init_ = true;
+    return true;
+  }
+
+  int32 stream_sizes[kFlashCacheEntryNumStreams];
+  COMPILE_ASSERT(sizeof(stream_sizes) == kFlashCacheEntryHeaderSize,
+                 invalid_cache_entry_header_size);
+
+  if (!store_->OpenEntry(id_) ||
+      !store_->ReadData(id_, stream_sizes, kFlashCacheEntryHeaderSize, 0)) {
+    return false;
+  }
+  for (int i = 0, offset = kFlashCacheEntryHeaderSize;
+       i < kFlashCacheEntryNumStreams; ++i) {
+    streams_[i].offset = offset;
+    streams_[i].size = stream_sizes[i];
+    offset += stream_sizes[i];
+  }
+  init_ = true;
+  return true;
+}
+
+bool CacheEntry::Close() {
+  DCHECK(init_ && !closed_);
+  if (OnDisk())
+    store_->CloseEntry(id_);
+  else if (!Save())
+    return false;
+  closed_ = true;
+  return true;
+}
+
+int32 CacheEntry::id() const {
+  DCHECK(init_);
+  return id_;
+}
+
+int32 CacheEntry::GetDataSize(int index) const {
+  DCHECK(init_);
+  return InvalidStream(index) ? 0 : streams_[index].size;
+}
+
+int CacheEntry::ReadData(int index, int offset, net::IOBuffer* buf,
+                         int buf_len) {
+  DCHECK(init_);
+  if (InvalidStream(index))
+    return net::ERR_INVALID_ARGUMENT;
+
+  int stream_size = streams_[index].size;
+  if (offset >= stream_size || offset < 0 || buf_len == 0)
+    return 0;
+  if (offset + buf_len > stream_size)
+    buf_len = stream_size - offset;
+
+  if (OnDisk()) {
+    offset += streams_[index].offset;
+    if (store_->ReadData(id_, buf->data(), buf_len, offset))
+      return buf_len;
+    return net::ERR_FAILED;
+  }
+  memcpy(buf->data(), &streams_[index].write_buffer[offset], buf_len);
+  return buf_len;
+}
+
+int CacheEntry::WriteData(int index, int offset, net::IOBuffer* buf,
+                          int buf_len) {
+  DCHECK(init_ && !closed_);
+  if (InvalidStream(index))
+    return net::ERR_INVALID_ARGUMENT;
+
+  DCHECK(offset >= 0 && buf_len >= 0);
+  Stream& stream = streams_[index];
+  size_t new_size = static_cast<size_t>(offset + buf_len);
+  if (new_size) {
+    DCHECK(offset == stream.size);

[rvargas (doing something else), 2012/12/05 00:21:01]

why?

[agayev, 2012/12/05 16:53:19]

Fixed.  It must be either overwrite (and/or truncate), in which case offset is
0, otherwise, must be an append.

[rvargas (doing something else), 2012/12/05 18:39:37]

Adding a DCHECK here for that behavior means that there is a layer above this
that will guarantee it. I mean, that's not part of the contract, even though it
is the common case. It is also not required by the current code... although that
doesn't mean that there's nothing else to do to really support arbitrary writes.

In other words, if you leave the DCHECK, we'd need a todo or comment stating
that it is just to reflect unimplemented functionality.

[agayev, 2012/12/05 20:11:11]

Added a todo.  I do not want to remove DCHECK without implementing arbitrary
writes, since, I'm sure I will forget and will start doing arbitrary writes and
it will fail silently...

+    if (stream.write_buffer.capacity() < new_size)
+      stream.write_buffer.reserve(new_size);
+    memcpy(&streams_[index].write_buffer[offset], buf->data(), buf_len);
+  }
+  stream.size = new_size;
+  return buf_len;
+}
+
+bool CacheEntry::OnDisk() const {
+  return id_ != -1;
+}
+
+bool CacheEntry::InvalidStream(int stream_index) const {
+  return stream_index < 0 && stream_index >= kFlashCacheEntryNumStreams;

[rvargas (doing something else), 2012/12/05 00:21:01]

return false? :)

[agayev, 2012/12/05 16:53:19]

Ugh.  Done.

+}
+
+int32 CacheEntry::Size() const {
+  DCHECK(init_);
+  int32 size = kFlashCacheEntryHeaderSize;
+  for (int i = 0; i < kFlashCacheEntryNumStreams; ++i)
+    size += streams_[i].size;
+  DCHECK(size > 0 && size <= kFlashSegmentFreeSpace);
+  return size;
+}
+
+bool CacheEntry::Save() {
+  DCHECK(init_ && !closed_ && !OnDisk());
+  int32 stream_sizes[kFlashCacheEntryNumStreams];
+  COMPILE_ASSERT(sizeof(stream_sizes) == kFlashCacheEntryHeaderSize,
+                 invalid_cache_entry_header_size);
+
+  for (int i = 0; i < kFlashCacheEntryNumStreams; ++i)
+    stream_sizes[i] = streams_[i].size;
+
+  if (!store_->CreateEntry(Size(), &id_))
+    return false;
+  if (!store_->WriteData(stream_sizes, kFlashCacheEntryHeaderSize))
+    return false;
+  for (int i = 0; i < kFlashCacheEntryNumStreams; ++i)

[rvargas (doing something else), 2012/12/05 00:21:01]

needs braces

[agayev, 2012/12/05 16:53:19]

Done.

+    if (!store_->WriteData(&streams_[i].write_buffer[0], streams_[i].size))
+      return false;
+  store_->CloseEntry(id_);
+  return true;
+}
+
+CacheEntry::Stream::Stream() : offset(0), size(0) {
+}
+
+}  // namespace disk_cache