1 // Copyright (c) 2013 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 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_FILE_H_ 6 #define NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_FILE_H_ 7 8 #include <string> 9 #include <vector> 10 11 #include "base/basictypes.h" 12 #include "base/containers/hash_tables.h" 13 #include "base/files/file_path.h" 14 #include "base/gtest_prod_util.h" 15 #include "base/logging.h" 16 #include "base/memory/scoped_ptr.h" 17 #include "base/pickle.h" 18 #include "base/port.h" 19 #include "net/base/cache_type.h" 20 #include "net/base/net_export.h" 21 #include "net/disk_cache/simple/simple_index.h" 22 23 namespace base { 24 class SingleThreadTaskRunner; 25 class TaskRunner; 26 } 27 28 namespace disk_cache { 29 30 const uint64 kSimpleIndexMagicNumber = GG_UINT64_C(0x656e74657220796f); 31 32 struct NET_EXPORT_PRIVATE SimpleIndexLoadResult { 33 SimpleIndexLoadResult(); 34 ~SimpleIndexLoadResult(); 35 void Reset(); 36 37 bool did_load; 38 SimpleIndex::EntrySet entries; 39 bool flush_required; 40 }; 41 42 // Simple Index File format is a pickle serialized data of IndexMetadata and 43 // EntryMetadata objects. The file format is as follows: one instance of 44 // serialized |IndexMetadata| followed serialized |EntryMetadata| entries 45 // repeated |number_of_entries| amount of times. To know more about the format, 46 // see SimpleIndexFile::Serialize() and SeeSimpleIndexFile::LoadFromDisk() 47 // methods. 48 // 49 // The non-static methods must run on the IO thread. All the real 50 // work is done in the static methods, which are run on the cache thread 51 // or in worker threads. Synchronization between methods is the 52 // responsibility of the caller. 53 class NET_EXPORT_PRIVATE SimpleIndexFile { 54 public: 55 class NET_EXPORT_PRIVATE IndexMetadata { 56 public: 57 IndexMetadata(); 58 IndexMetadata(uint64 number_of_entries, uint64 cache_size); 59 60 void Serialize(Pickle* pickle) const; 61 bool Deserialize(PickleIterator* it); 62 63 bool CheckIndexMetadata(); 64 65 uint64 GetNumberOfEntries() { return number_of_entries_; } 66 67 private: 68 FRIEND_TEST_ALL_PREFIXES(IndexMetadataTest, Basics); 69 FRIEND_TEST_ALL_PREFIXES(IndexMetadataTest, Serialize); 70 71 uint64 magic_number_; 72 uint32 version_; 73 uint64 number_of_entries_; 74 uint64 cache_size_; // Total cache storage size in bytes. 75 }; 76 77 SimpleIndexFile(base::SingleThreadTaskRunner* cache_thread, 78 base::TaskRunner* worker_pool, 79 net::CacheType cache_type, 80 const base::FilePath& cache_directory); 81 virtual ~SimpleIndexFile(); 82 83 // Get index entries based on current disk context. 84 virtual void LoadIndexEntries(base::Time cache_last_modified, 85 const base::Closure& callback, 86 SimpleIndexLoadResult* out_result); 87 88 // Write the specified set of entries to disk. 89 virtual void WriteToDisk(const SimpleIndex::EntrySet& entry_set, 90 uint64 cache_size, 91 const base::TimeTicks& start, 92 bool app_on_background); 93 94 private: 95 friend class WrappedSimpleIndexFile; 96 97 // Used for cache directory traversal. 98 typedef base::Callback<void (const base::FilePath&)> EntryFileCallback; 99 100 // When loading the entries from disk, add this many extra hash buckets to 101 // prevent reallocation on the IO thread when merging in new live entries. 102 static const int kExtraSizeForMerge = 512; 103 104 // Synchronous (IO performing) implementation of LoadIndexEntries. 105 static void SyncLoadIndexEntries(net::CacheType cache_type, 106 base::Time cache_last_modified, 107 const base::FilePath& cache_directory, 108 const base::FilePath& index_file_path, 109 SimpleIndexLoadResult* out_result); 110 111 // Load the index file from disk returning an EntrySet. 112 static void SyncLoadFromDisk(const base::FilePath& index_filename, 113 base::Time* out_last_cache_seen_by_index, 114 SimpleIndexLoadResult* out_result); 115 116 // Returns a scoped_ptr for a newly allocated Pickle containing the serialized 117 // data to be written to a file. Note: the pickle is not in a consistent state 118 // immediately after calling this menthod, one needs to call 119 // SerializeFinalData to make it ready to write to a file. 120 static scoped_ptr<Pickle> Serialize( 121 const SimpleIndexFile::IndexMetadata& index_metadata, 122 const SimpleIndex::EntrySet& entries); 123 124 // Appends cache modification time data to the serialized format. This is 125 // performed on a thread accessing the disk. It is not combined with the main 126 // serialization path to avoid extra thread hops or copying the pickle to the 127 // worker thread. 128 static bool SerializeFinalData(base::Time cache_modified, Pickle* pickle); 129 130 // Given the contents of an index file |data| of length |data_len|, returns 131 // the corresponding EntrySet. Returns NULL on error. 132 static void Deserialize(const char* data, int data_len, 133 base::Time* out_cache_last_modified, 134 SimpleIndexLoadResult* out_result); 135 136 // Implemented either in simple_index_file_posix.cc or 137 // simple_index_file_win.cc. base::FileEnumerator turned out to be very 138 // expensive in terms of memory usage therefore it's used only on non-POSIX 139 // environments for convenience (for now). Returns whether the traversal 140 // succeeded. 141 static bool TraverseCacheDirectory( 142 const base::FilePath& cache_path, 143 const EntryFileCallback& entry_file_callback); 144 145 // Writes the index file to disk atomically. 146 static void SyncWriteToDisk(net::CacheType cache_type, 147 const base::FilePath& cache_directory, 148 const base::FilePath& index_filename, 149 const base::FilePath& temp_index_filename, 150 scoped_ptr<Pickle> pickle, 151 const base::TimeTicks& start_time, 152 bool app_on_background); 153 154 // Scan the index directory for entries, returning an EntrySet of all entries 155 // found. 156 static void SyncRestoreFromDisk(const base::FilePath& cache_directory, 157 const base::FilePath& index_file_path, 158 SimpleIndexLoadResult* out_result); 159 160 // Determines if an index file is stale relative to the time of last 161 // modification of the cache directory. Obsolete, used only for a histogram to 162 // compare with the new method. 163 // TODO(pasko): remove this method after getting enough data. 164 static bool LegacyIsIndexFileStale(base::Time cache_last_modified, 165 const base::FilePath& index_file_path); 166 167 struct PickleHeader : public Pickle::Header { 168 uint32 crc; 169 }; 170 171 const scoped_refptr<base::SingleThreadTaskRunner> cache_thread_; 172 const scoped_refptr<base::TaskRunner> worker_pool_; 173 const net::CacheType cache_type_; 174 const base::FilePath cache_directory_; 175 const base::FilePath index_file_; 176 const base::FilePath temp_index_file_; 177 178 static const char kIndexDirectory[]; 179 static const char kIndexFileName[]; 180 static const char kTempIndexFileName[]; 181 182 DISALLOW_COPY_AND_ASSIGN(SimpleIndexFile); 183 }; 184 185 186 } // namespace disk_cache 187 188 #endif // NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_FILE_H_ 189
