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