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.
5 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_FILE_H_
6 #define NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_FILE_H_
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"
24 class SingleThreadTaskRunner;
28 namespace disk_cache {
30 const uint64 kSimpleIndexMagicNumber = GG_UINT64_C(0x656e74657220796f);
32 struct NET_EXPORT_PRIVATE SimpleIndexLoadResult {
33 SimpleIndexLoadResult();
34 ~SimpleIndexLoadResult();
38 SimpleIndex::EntrySet entries;
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()
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 {
55 class NET_EXPORT_PRIVATE IndexMetadata {
58 IndexMetadata(uint64 number_of_entries, uint64 cache_size);
60 void Serialize(Pickle* pickle) const;
61 bool Deserialize(PickleIterator* it);
63 bool CheckIndexMetadata();
65 uint64 GetNumberOfEntries() { return number_of_entries_; }
68 FRIEND_TEST_ALL_PREFIXES(IndexMetadataTest, Basics);
69 FRIEND_TEST_ALL_PREFIXES(IndexMetadataTest, Serialize);
73 uint64 number_of_entries_;
74 uint64 cache_size_; // Total cache storage size in bytes.
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();
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);
88 // Write the specified set of entries to disk.
89 virtual void WriteToDisk(const SimpleIndex::EntrySet& entry_set,
91 const base::TimeTicks& start,
92 bool app_on_background);
95 friend class WrappedSimpleIndexFile;
97 // Used for cache directory traversal.
98 typedef base::Callback<void (const base::FilePath&)> EntryFileCallback;
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;
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);
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);
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);
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
128 static bool SerializeFinalData(base::Time cache_modified, Pickle* pickle);
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);
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
141 static bool TraverseCacheDirectory(
142 const base::FilePath& cache_path,
143 const EntryFileCallback& entry_file_callback);
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);
154 // Scan the index directory for entries, returning an EntrySet of all entries
156 static void SyncRestoreFromDisk(const base::FilePath& cache_directory,
157 const base::FilePath& index_file_path,
158 SimpleIndexLoadResult* out_result);
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);
167 struct PickleHeader : public Pickle::Header {
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_;
178 static const char kIndexDirectory[];
179 static const char kIndexFileName[];
180 static const char kTempIndexFileName[];
182 DISALLOW_COPY_AND_ASSIGN(SimpleIndexFile);
186 } // namespace disk_cache
188 #endif // NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_FILE_H_