net/disk_cache/blockfile/storage_block.h

   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
  13 namespace 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();
  30 template<typename T>
  31 class StorageBlock : public FileBlock {
  32  public:
  33   StorageBlock(MappedFile* file, Addr address);
  34   virtual ~StorageBlock();
  35
  36   // FileBlock interface.
  37   void* buffer() const override;
  38   size_t size() const override;
  39   int offset() const override;
  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_