src/net/disk_cache/flash/internal_entry.cc

   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 "net/disk_cache/flash/internal_entry.h"
   6
   7 #include "base/memory/ref_counted.h"
   8 #include "net/base/completion_callback.h"
   9 #include "net/base/io_buffer.h"
  10 #include "net/base/net_errors.h"
  11 #include "net/disk_cache/flash/log_store.h"
  12 #include "net/disk_cache/flash/log_store_entry.h"
  13
  14 using net::IOBuffer;
  15 using net::StringIOBuffer;
  16 using net::CompletionCallback;
  17
  18 namespace disk_cache {
  19
  20 KeyAndStreamSizes::KeyAndStreamSizes() {
  21 }
  22
  23 InternalEntry::InternalEntry(const std::string& key, LogStore* store)
  24     : store_(store),
  25       entry_(new LogStoreEntry(store_)) {
  26   entry_->Init();
  27   WriteKey(entry_.get(), key);
  28 }
  29
  30 InternalEntry::InternalEntry(int32 id, LogStore* store)
  31     : store_(store),
  32       entry_(new LogStoreEntry(store_, id)) {
  33 }
  34
  35 InternalEntry::~InternalEntry() {
  36 }
  37
  38 scoped_ptr<KeyAndStreamSizes> InternalEntry::Init() {
  39   scoped_ptr<KeyAndStreamSizes> null;
  40   if (entry_->IsNew())
  41     return null.Pass();
  42   if (!entry_->Init())
  43     return null.Pass();
  44
  45   scoped_ptr<KeyAndStreamSizes> rv(new KeyAndStreamSizes);
  46   if (!ReadKey(entry_.get(), &rv->key))
  47     return null.Pass();
  48   for (int i = 0; i < kFlashLogStoreEntryNumStreams; ++i)
  49     rv->stream_sizes[i] = entry_->GetDataSize(i+1);
  50   return rv.Pass();
  51 }
  52
  53 int32 InternalEntry::GetDataSize(int index) const {
  54   return entry_->GetDataSize(++index);
  55 }
  56
  57 int InternalEntry::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
  58                             const CompletionCallback& callback) {
  59   return entry_->ReadData(++index, offset, buf, buf_len);
  60 }
  61
  62 int InternalEntry::WriteData(int index, int offset, IOBuffer* buf, int buf_len,
  63                              const CompletionCallback& callback) {
  64   return entry_->WriteData(++index, offset, buf, buf_len);
  65 }
  66
  67 void InternalEntry::Close() {
  68   entry_->Close();
  69 }
  70
  71 bool InternalEntry::WriteKey(LogStoreEntry* entry, const std::string& key) {
  72   int key_size = static_cast<int>(key.size());
  73   scoped_refptr<IOBuffer> key_buf(new StringIOBuffer(key));
  74   return entry->WriteData(0, 0, key_buf.get(), key_size) == key_size;
  75 }
  76
  77 bool InternalEntry::ReadKey(LogStoreEntry* entry, std::string* key) {
  78   int key_size = entry->GetDataSize(0);
  79   scoped_refptr<net::IOBuffer> key_buf(new net::IOBuffer(key_size));
  80   if (entry->ReadData(0, 0, key_buf.get(), key_size) != key_size)
  81     return false;
  82   key->assign(key_buf->data(), key_size);
  83   return true;
  84 }
  85
  86 }  // namespace disk_cache