Adding disk_cache::Entry implementation.

net/disk_cache/flash/log_store_entry.cc

 // 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/format.h"
 #include "net/disk_cache/flash/log_store.h"
 #include "net/disk_cache/flash/log_store_entry.h"
 
 namespace disk_cache {
 
 LogStoreEntry::LogStoreEntry(LogStore* store)
     : store_(store), id_(-1), init_(false), closed_(false), deleted_(false) {
   DCHECK(store);
 }
 
 LogStoreEntry::LogStoreEntry(LogStore* store, int32 id)
     : store_(store), id_(id), init_(false), closed_(false), deleted_(false) {
   DCHECK(store);
 }
 
 LogStoreEntry::~LogStoreEntry() {
   DCHECK(!init_ || closed_);
 }
 
 bool LogStoreEntry::Init() {
   DCHECK(!init_);
-  if (!ReadOnly()) {
+  if (IsNew()) {
     init_ = true;
     return true;
   }
 
   int32 stream_sizes[kFlashLogStoreEntryNumStreams];
   COMPILE_ASSERT(sizeof(stream_sizes) == kFlashLogStoreEntryHeaderSize,
                  invalid_log_store_entry_header_size);
 
   if (!store_->OpenEntry(id_) ||
       !store_->ReadData(id_, stream_sizes, kFlashLogStoreEntryHeaderSize, 0)) {
     return false;
   }
   for (int i = 0, offset = kFlashLogStoreEntryHeaderSize;
        i < kFlashLogStoreEntryNumStreams; ++i) {
     streams_[i].offset = offset;
     streams_[i].size = stream_sizes[i];
     offset += stream_sizes[i];
   }
   init_ = true;
   return true;
 }
 
 bool LogStoreEntry::Close() {
   DCHECK(init_ && !closed_);
 
-  if (ReadOnly()) {
+  if (IsNew()) {
+    closed_ = deleted_ ? true : Save();
+  } else {
     store_->CloseEntry(id_);
     if (deleted_)
       store_->DeleteEntry(id_, Size());
     closed_ = true;
-  } else {
-    closed_ = deleted_ ? true : Save();
   }
   return closed_;
 }
 
 int32 LogStoreEntry::id() const {
   DCHECK(init_);
   return id_;
 }
 
 int32 LogStoreEntry::GetDataSize(int index) const {
   DCHECK(init_);
   return InvalidStream(index) ? 0 : streams_[index].size;
 }
 
 int LogStoreEntry::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 (ReadOnly()) {
+  if (!IsNew()) {
     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 LogStoreEntry::WriteData(int index, int offset, net::IOBuffer* buf,
@@ skipping 15 matching lines @@
   }
   stream.size = new_size;
   return buf_len;
 }
 
 void LogStoreEntry::Delete() {
   DCHECK(init_ && !closed_);
   deleted_ = true;
 }
 
-bool LogStoreEntry::ReadOnly() const {
-  return id_ != -1;
+bool LogStoreEntry::IsNew() const {
+  return id_ == -1;
 }
 
 bool LogStoreEntry::InvalidStream(int stream_index) const {
   return stream_index < 0 || stream_index >= kFlashLogStoreEntryNumStreams;
 }
 
 int32 LogStoreEntry::Size() const {
   DCHECK(init_);
   int32 size = kFlashLogStoreEntryHeaderSize;
   for (int i = 0; i < kFlashLogStoreEntryNumStreams; ++i)
     size += streams_[i].size;
   DCHECK(size > 0 && size <= kFlashSegmentFreeSpace);
   return size;
 }
 
 bool LogStoreEntry::Save() {
-  DCHECK(init_ && !closed_ && !deleted_ && !ReadOnly());
+  DCHECK(init_ && !closed_ && !deleted_ && IsNew());
   int32 stream_sizes[kFlashLogStoreEntryNumStreams];
   COMPILE_ASSERT(sizeof(stream_sizes) == kFlashLogStoreEntryHeaderSize,
                  invalid_log_store_entry_header_size);
 
   for (int i = 0; i < kFlashLogStoreEntryNumStreams; ++i)
     stream_sizes[i] = streams_[i].size;
 
   if (!store_->CreateEntry(Size(), &id_))
     return false;
   if (!store_->WriteData(stream_sizes, kFlashLogStoreEntryHeaderSize))
     return false;
   for (int i = 0; i < kFlashLogStoreEntryNumStreams; ++i) {
     if (streams_[i].size > 0 &&
         !store_->WriteData(&streams_[i].write_buffer[0], streams_[i].size)) {
       return false;
     }
   }
   store_->CloseEntry(id_);
   return true;
 }
 
 LogStoreEntry::Stream::Stream() : offset(0), size(0) {
 }
 
 LogStoreEntry::Stream::~Stream() {
 }
 
 }  // namespace disk_cache