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// See net/disk_cache/disk_cache.h for the public interface.
6
7#ifndef NET_DISK_CACHE_BLOCKFILE_STORAGE_BLOCK_H_
8#define NET_DISK_CACHE_BLOCKFILE_STORAGE_BLOCK_H_
9
10#include "net/disk_cache/blockfile/addr.h"
11#include "net/disk_cache/blockfile/mapped_file.h"
12
13namespace disk_cache {
14
15// This class encapsulates common behavior of a single "block" of data that is
16// stored on a block-file. It implements the FileBlock interface, so it can be
17// serialized directly to the backing file.
18// This object provides a memory buffer for the related data, and it can be used
19// to actually share that memory with another instance of the class.
20//
21// The following example shows how to share storage with another object:
22//    StorageBlock<TypeA> a(file, address);
23//    StorageBlock<TypeB> b(file, address);
24//    a.Load();
25//    DoSomething(a.Data());
26//    b.SetData(a.Data());
27//    ModifySomething(b.Data());
28//    // Data modified on the previous call will be saved by b's destructor.
29//    b.set_modified();
30template<typename T>
31class StorageBlock : public FileBlock {
32 public:
33  StorageBlock(MappedFile* file, Addr address);
34  virtual ~StorageBlock();
35
36  // FileBlock interface.
37  virtual void* buffer() const;
38  virtual size_t size() const;
39  virtual int offset() const;
40
41  // Allows the overide of dummy values passed on the constructor.
42  bool LazyInit(MappedFile* file, Addr address);
43
44  // Sets the internal storage to share the memory provided by other instance.
45  void SetData(T* other);
46
47  // Deletes the data, even if it was modified and not saved. This object must
48  // own the memory buffer (it cannot be shared).
49  void Discard();
50
51  // Stops sharing the data with another object.
52  void StopSharingData();
53
54  // Sets the object to lazily save the in-memory data on destruction.
55  void set_modified();
56
57  // Forgets that the data was modified, so it's not lazily saved.
58  void clear_modified();
59
60  // Gets a pointer to the internal storage (allocates storage if needed).
61  T* Data();
62
63  // Returns true if there is data associated with this object.
64  bool HasData() const;
65
66  // Returns true if the internal hash is correct.
67  bool VerifyHash() const;
68
69  // Returns true if this object owns the data buffer, false if it is shared.
70  bool own_data() const;
71
72  const Addr address() const;
73
74  // Loads and store the data.
75  bool Load();
76  bool Store();
77  bool Load(FileIOCallback* callback, bool* completed);
78  bool Store(FileIOCallback* callback, bool* completed);
79
80 private:
81  void AllocateData();
82  void DeleteData();
83  uint32 CalculateHash() const;
84
85  T* data_;
86  MappedFile* file_;
87  Addr address_;
88  bool modified_;
89  bool own_data_;  // Is data_ owned by this object or shared with someone else.
90  bool extended_;  // Used to store an entry of more than one block.
91
92  DISALLOW_COPY_AND_ASSIGN(StorageBlock);
93};
94
95}  // namespace disk_cache
96
97#endif  // NET_DISK_CACHE_BLOCKFILE_STORAGE_BLOCK_H_
98