Home | History | Annotate | Download | only in blockfile 
      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   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