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
23namespace base {
24class SingleThreadTaskRunner;
25class TaskRunner;
26}
27
28namespace disk_cache {
29
30const uint64 kSimpleIndexMagicNumber = GG_UINT64_C(0x656e74657220796f);
31
32struct 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.
53class 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