net/disk_cache/simple/simple_index_file.h

   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 <stdint.h>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/containers/hash_tables.h"
  14 #include "base/files/file_path.h"
  15 #include "base/gtest_prod_util.h"
  16 #include "base/logging.h"
  17 #include "base/memory/scoped_ptr.h"
  18 #include "base/pickle.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 = 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(base::Pickle* pickle) const;
  61     bool Deserialize(base::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(
  78       const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
  79       const scoped_refptr<base::TaskRunner>& worker_pool,
  80       net::CacheType cache_type,
  81       const base::FilePath& cache_directory);
  82   virtual ~SimpleIndexFile();
  83
  84   // Get index entries based on current disk context.
  85   virtual void LoadIndexEntries(base::Time cache_last_modified,
  86                                 const base::Closure& callback,
  87                                 SimpleIndexLoadResult* out_result);
  88
  89   // Write the specified set of entries to disk.
  90   virtual void WriteToDisk(const SimpleIndex::EntrySet& entry_set,
  91                            uint64 cache_size,
  92                            const base::TimeTicks& start,
  93                            bool app_on_background,
  94                            const base::Closure& callback);
  95
  96  private:
  97   friend class WrappedSimpleIndexFile;
  98
  99   // Used for cache directory traversal.
 100   typedef base::Callback<void (const base::FilePath&)> EntryFileCallback;
 101
 102   // When loading the entries from disk, add this many extra hash buckets to
 103   // prevent reallocation on the IO thread when merging in new live entries.
 104   static const int kExtraSizeForMerge = 512;
 105
 106   // Synchronous (IO performing) implementation of LoadIndexEntries.
 107   static void SyncLoadIndexEntries(net::CacheType cache_type,
 108                                    base::Time cache_last_modified,
 109                                    const base::FilePath& cache_directory,
 110                                    const base::FilePath& index_file_path,
 111                                    SimpleIndexLoadResult* out_result);
 112
 113   // Load the index file from disk returning an EntrySet.
 114   static void SyncLoadFromDisk(const base::FilePath& index_filename,
 115                                base::Time* out_last_cache_seen_by_index,
 116                                SimpleIndexLoadResult* out_result);
 117
 118   // Returns a scoped_ptr for a newly allocated base::Pickle containing the
 119   // serialized
 120   // data to be written to a file. Note: the pickle is not in a consistent state
 121   // immediately after calling this menthod, one needs to call
 122   // SerializeFinalData to make it ready to write to a file.
 123   static scoped_ptr<base::Pickle> Serialize(
 124       const SimpleIndexFile::IndexMetadata& index_metadata,
 125       const SimpleIndex::EntrySet& entries);
 126
 127   // Appends cache modification time data to the serialized format. This is
 128   // performed on a thread accessing the disk. It is not combined with the main
 129   // serialization path to avoid extra thread hops or copying the pickle to the
 130   // worker thread.
 131   static bool SerializeFinalData(base::Time cache_modified,
 132                                  base::Pickle* pickle);
 133
 134   // Given the contents of an index file |data| of length |data_len|, returns
 135   // the corresponding EntrySet. Returns NULL on error.
 136   static void Deserialize(const char* data, int data_len,
 137                           base::Time* out_cache_last_modified,
 138                           SimpleIndexLoadResult* out_result);
 139
 140   // Implemented either in simple_index_file_posix.cc or
 141   // simple_index_file_win.cc. base::FileEnumerator turned out to be very
 142   // expensive in terms of memory usage therefore it's used only on non-POSIX
 143   // environments for convenience (for now). Returns whether the traversal
 144   // succeeded.
 145   static bool TraverseCacheDirectory(
 146       const base::FilePath& cache_path,
 147       const EntryFileCallback& entry_file_callback);
 148
 149   // Writes the index file to disk atomically.
 150   static void SyncWriteToDisk(net::CacheType cache_type,
 151                               const base::FilePath& cache_directory,
 152                               const base::FilePath& index_filename,
 153                               const base::FilePath& temp_index_filename,
 154                               scoped_ptr<base::Pickle> pickle,
 155                               const base::TimeTicks& start_time,
 156                               bool app_on_background);
 157
 158   // Scan the index directory for entries, returning an EntrySet of all entries
 159   // found.
 160   static void SyncRestoreFromDisk(const base::FilePath& cache_directory,
 161                                   const base::FilePath& index_file_path,
 162                                   SimpleIndexLoadResult* out_result);
 163
 164   // Determines if an index file is stale relative to the time of last
 165   // modification of the cache directory. Obsolete, used only for a histogram to
 166   // compare with the new method.
 167   // TODO(pasko): remove this method after getting enough data.
 168   static bool LegacyIsIndexFileStale(base::Time cache_last_modified,
 169                                      const base::FilePath& index_file_path);
 170
 171   struct PickleHeader : public base::Pickle::Header {
 172     uint32 crc;
 173   };
 174
 175   const scoped_refptr<base::SingleThreadTaskRunner> cache_thread_;
 176   const scoped_refptr<base::TaskRunner> worker_pool_;
 177   const net::CacheType cache_type_;
 178   const base::FilePath cache_directory_;
 179   const base::FilePath index_file_;
 180   const base::FilePath temp_index_file_;
 181
 182   static const char kIndexDirectory[];
 183   static const char kIndexFileName[];
 184   static const char kTempIndexFileName[];
 185
 186   DISALLOW_COPY_AND_ASSIGN(SimpleIndexFile);
 187 };
 188
 189
 190 }  // namespace disk_cache
 191
 192 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_FILE_H_