| OLD | NEW |
| (Empty) |
| 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_BLOCK_FILES_H_ | |
| 8 #define NET_DISK_CACHE_BLOCK_FILES_H_ | |
| 9 | |
| 10 #include <vector> | |
| 11 | |
| 12 #include "base/files/file_path.h" | |
| 13 #include "base/gtest_prod_util.h" | |
| 14 #include "base/memory/scoped_ptr.h" | |
| 15 #include "net/base/net_export.h" | |
| 16 #include "net/disk_cache/addr.h" | |
| 17 #include "net/disk_cache/disk_format_base.h" | |
| 18 #include "net/disk_cache/mapped_file.h" | |
| 19 | |
| 20 namespace base { | |
| 21 class ThreadChecker; | |
| 22 } | |
| 23 | |
| 24 namespace disk_cache { | |
| 25 | |
| 26 // An instance of this class represents the header of a block file in memory. | |
| 27 // Note that this class doesn't perform any file operation (as in it only deals | |
| 28 // with entities in memory). | |
| 29 // The header of a block file (and hence, this object) is all that is needed to | |
| 30 // perform common operations like allocating or releasing space for storage; | |
| 31 // actual access to that storage, however, is not performed through this class. | |
| 32 class NET_EXPORT_PRIVATE BlockHeader { | |
| 33 public: | |
| 34 BlockHeader(); | |
| 35 explicit BlockHeader(BlockFileHeader* header); | |
| 36 explicit BlockHeader(MappedFile* file); | |
| 37 BlockHeader(const BlockHeader& other); | |
| 38 ~BlockHeader(); | |
| 39 | |
| 40 // Creates a new entry of |size| blocks on the allocation map, updating the | |
| 41 // apropriate counters. | |
| 42 bool CreateMapBlock(int size, int* index); | |
| 43 | |
| 44 // Deletes the block pointed by |index|. | |
| 45 void DeleteMapBlock(int index, int block_size); | |
| 46 | |
| 47 // Returns true if the specified block is used. | |
| 48 bool UsedMapBlock(int index, int size); | |
| 49 | |
| 50 // Restores the "empty counters" and allocation hints. | |
| 51 void FixAllocationCounters(); | |
| 52 | |
| 53 // Returns true if the current block file should not be used as-is to store | |
| 54 // more records. |block_count| is the number of blocks to allocate. | |
| 55 bool NeedToGrowBlockFile(int block_count) const; | |
| 56 | |
| 57 // Returns true if this block file can be used to store an extra record of | |
| 58 // size |block_count|. | |
| 59 bool CanAllocate(int block_count) const; | |
| 60 | |
| 61 // Returns the number of empty blocks for this file. | |
| 62 int EmptyBlocks() const; | |
| 63 | |
| 64 // Returns the minumum number of allocations that can be satisfied. | |
| 65 int MinimumAllocations() const; | |
| 66 | |
| 67 // Returns the number of blocks that this file can store. | |
| 68 int Capacity() const; | |
| 69 | |
| 70 // Returns true if the counters look OK. | |
| 71 bool ValidateCounters() const; | |
| 72 | |
| 73 // Returns the identifiers of this and the next file (0 if there is none). | |
| 74 int FileId() const; | |
| 75 int NextFileId() const; | |
| 76 | |
| 77 // Returns the size of the wrapped structure (BlockFileHeader). | |
| 78 int Size() const; | |
| 79 | |
| 80 // Returns a pointer to the underlying BlockFileHeader. | |
| 81 // TODO(rvargas): This may be removed with the support for V2. | |
| 82 BlockFileHeader* Header(); | |
| 83 | |
| 84 private: | |
| 85 BlockFileHeader* header_; | |
| 86 }; | |
| 87 | |
| 88 typedef std::vector<BlockHeader> BlockFilesBitmaps; | |
| 89 | |
| 90 // This class handles the set of block-files open by the disk cache. | |
| 91 class NET_EXPORT_PRIVATE BlockFiles { | |
| 92 public: | |
| 93 explicit BlockFiles(const base::FilePath& path); | |
| 94 ~BlockFiles(); | |
| 95 | |
| 96 // Performs the object initialization. create_files indicates if the backing | |
| 97 // files should be created or just open. | |
| 98 bool Init(bool create_files); | |
| 99 | |
| 100 // Returns the file that stores a given address. | |
| 101 MappedFile* GetFile(Addr address); | |
| 102 | |
| 103 // Creates a new entry on a block file. block_type indicates the size of block | |
| 104 // to be used (as defined on cache_addr.h), block_count is the number of | |
| 105 // blocks to allocate, and block_address is the address of the new entry. | |
| 106 bool CreateBlock(FileType block_type, int block_count, Addr* block_address); | |
| 107 | |
| 108 // Removes an entry from the block files. If deep is true, the storage is zero | |
| 109 // filled; otherwise the entry is removed but the data is not altered (must be | |
| 110 // already zeroed). | |
| 111 void DeleteBlock(Addr address, bool deep); | |
| 112 | |
| 113 // Close all the files and set the internal state to be initializad again. The | |
| 114 // cache is being purged. | |
| 115 void CloseFiles(); | |
| 116 | |
| 117 // Sends UMA stats. | |
| 118 void ReportStats(); | |
| 119 | |
| 120 // Returns true if the blocks pointed by a given address are currently used. | |
| 121 // This method is only intended for debugging. | |
| 122 bool IsValid(Addr address); | |
| 123 | |
| 124 private: | |
| 125 // Set force to true to overwrite the file if it exists. | |
| 126 bool CreateBlockFile(int index, FileType file_type, bool force); | |
| 127 bool OpenBlockFile(int index); | |
| 128 | |
| 129 // Attemp to grow this file. Fails if the file cannot be extended anymore. | |
| 130 bool GrowBlockFile(MappedFile* file, BlockFileHeader* header); | |
| 131 | |
| 132 // Returns the appropriate file to use for a new block. | |
| 133 MappedFile* FileForNewBlock(FileType block_type, int block_count); | |
| 134 | |
| 135 // Returns the next block file on this chain, creating new files if needed. | |
| 136 MappedFile* NextFile(MappedFile* file); | |
| 137 | |
| 138 // Creates an empty block file and returns its index. | |
| 139 int CreateNextBlockFile(FileType block_type); | |
| 140 | |
| 141 // Removes a chained block file that is now empty. | |
| 142 bool RemoveEmptyFile(FileType block_type); | |
| 143 | |
| 144 // Restores the header of a potentially inconsistent file. | |
| 145 bool FixBlockFileHeader(MappedFile* file); | |
| 146 | |
| 147 // Retrieves stats for the given file index. | |
| 148 void GetFileStats(int index, int* used_count, int* load); | |
| 149 | |
| 150 // Returns the filename for a given file index. | |
| 151 base::FilePath Name(int index); | |
| 152 | |
| 153 bool init_; | |
| 154 char* zero_buffer_; // Buffer to speed-up cleaning deleted entries. | |
| 155 base::FilePath path_; // Path to the backing folder. | |
| 156 std::vector<MappedFile*> block_files_; // The actual files. | |
| 157 scoped_ptr<base::ThreadChecker> thread_checker_; | |
| 158 | |
| 159 FRIEND_TEST_ALL_PREFIXES(DiskCacheTest, BlockFiles_ZeroSizeFile); | |
| 160 FRIEND_TEST_ALL_PREFIXES(DiskCacheTest, BlockFiles_TruncatedFile); | |
| 161 FRIEND_TEST_ALL_PREFIXES(DiskCacheTest, BlockFiles_InvalidFile); | |
| 162 FRIEND_TEST_ALL_PREFIXES(DiskCacheTest, BlockFiles_Stats); | |
| 163 | |
| 164 DISALLOW_COPY_AND_ASSIGN(BlockFiles); | |
| 165 }; | |
| 166 | |
| 167 } // namespace disk_cache | |
| 168 | |
| 169 #endif // NET_DISK_CACHE_BLOCK_FILES_H_ | |
| OLD | NEW |