SimpleCache: open with fewer seeks.

net/disk_cache/simple/simple_synchronous_entry.h

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_
 
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 23 matching lines @@
 // This class handles the passing of data about the entry between
 // SimpleEntryImplementation and SimpleSynchronousEntry and the computation of
 // file offsets based on the data size for all streams.
 class NET_EXPORT_PRIVATE SimpleEntryStat {
  public:
   SimpleEntryStat(base::Time last_used,
                   base::Time last_modified,
                   const int32_t data_size[],
                   const int32_t sparse_data_size);
 
-  int GetOffsetInFile(const std::string& key,
-                      int offset,
-                      int stream_index) const;
-  int GetEOFOffsetInFile(const std::string& key, int stream_index) const;
-  int GetLastEOFOffsetInFile(const std::string& key, int file_index) const;
-  int64_t GetFileSize(const std::string& key, int file_index) const;
+  int GetOffsetInFile(size_t key_length, int offset, int stream_index) const;
+  int GetEOFOffsetInFile(size_t key_length, int stream_index) const;
+  int GetLastEOFOffsetInFile(size_t key_length, int file_index) const;
+  int64_t GetFileSize(size_t key_length, int file_index) const;
 
   base::Time last_used() const { return last_used_; }
   base::Time last_modified() const { return last_modified_; }
   void set_last_used(base::Time last_used) { last_used_ = last_used; }
   void set_last_modified(base::Time last_modified) {
     last_modified_ = last_modified;
   }
 
   int32_t data_size(int stream_index) const { return data_size_[stream_index]; }
   void set_data_size(int stream_index, int data_size) {
@@ skipping 47 matching lines @@
     EntryOperationData(int64_t sparse_offset_p, int buf_len_p);
 
     int index;
     int offset;
     int64_t sparse_offset;
     int buf_len;
     bool truncate;
     bool doomed;
   };
 
+  // Opens a disk cache entry on disk. The |key| parameter is optional, if empty
+  // the operation may be slower. The |entry_hash| parameter is required.
+  // |had_index| is provided only for histograms.

[Randy Smith (Not in Mondays), 2016/05/17 20:04:07]

I'm torn here, because for someone reading the code, knowing that the key
parameter will exist except for the iteration case is really really useful, but
it's not appropriate to document at this level.  Maybe document in the CL
description and/or the first location upstack from this call that has knowledge
of the calling API?

[gavinp, 2016/05/18 15:46:00]

Done. Documented it at SetKey in SimpleEntryImpl.

   static void OpenEntry(net::CacheType cache_type,
                         const base::FilePath& path,
+                        const std::string& key,
                         uint64_t entry_hash,
                         bool had_index,
                         SimpleEntryCreationResults* out_results);
 
   static void CreateEntry(net::CacheType cache_type,
                           const base::FilePath& path,
                           const std::string& key,
                           uint64_t entry_hash,
                           bool had_index,
                           SimpleEntryCreationResults* out_results);
@@ skipping 14 matching lines @@
   // |key_hashes|. Succeeds only when all entries are deleted. Returns a net
   // error code.
   static int DoomEntrySet(const std::vector<uint64_t>* key_hashes,
                           const base::FilePath& path);
 
   // N.B. ReadData(), WriteData(), CheckEOFRecord() and Close() may block on IO.
   void ReadData(const EntryOperationData& in_entry_op,
                 net::IOBuffer* out_buf,
                 uint32_t* out_crc32,
                 SimpleEntryStat* entry_stat,
-                int* out_result) const;
+                int* out_result);
   void WriteData(const EntryOperationData& in_entry_op,
                  net::IOBuffer* in_buf,
                  SimpleEntryStat* out_entry_stat,
                  int* out_result);
   void CheckEOFRecord(int index,
                       const SimpleEntryStat& entry_stat,
                       uint32_t expected_crc32,
                       int* out_result) const;
 
   void ReadSparseData(const EntryOperationData& in_entry_op,
@@ skipping 39 matching lines @@
     int64_t file_offset;
 
     bool operator<(const SparseRange& other) const {
       return offset < other.offset;
     }
   };
 
   SimpleSynchronousEntry(net::CacheType cache_type,
                          const base::FilePath& path,
                          const std::string& key,
-                         uint64_t entry_hash);
+                         uint64_t entry_hash,
+                         bool had_index);
 
   // Like Entry, the SimpleSynchronousEntry self releases when Close() is
   // called.
   ~SimpleSynchronousEntry();
 
   // Tries to open one of the cache entry files. Succeeds if the open succeeds
   // or if the file was not found and is allowed to be omitted if the
   // corresponding stream is empty.
   bool MaybeOpenFile(int file_index,
                      base::File::Error* out_error);
   // Creates one of the cache entry files if necessary. If the file is allowed
   // to be omitted if the corresponding stream is empty, and if |file_required|
   // is FILE_NOT_REQUIRED, then the file is not created; otherwise, it is.
   bool MaybeCreateFile(int file_index,
                        FileRequired file_required,
                        base::File::Error* out_error);
-  bool OpenFiles(bool had_index,
-                 SimpleEntryStat* out_entry_stat);
-  bool CreateFiles(bool had_index,
-                   SimpleEntryStat* out_entry_stat);
+  bool OpenFiles(SimpleEntryStat* out_entry_stat);
+  bool CreateFiles(SimpleEntryStat* out_entry_stat);
   void CloseFile(int index);
   void CloseFiles();
 
-  // Returns a net error, i.e. net::OK on success. |had_index| is passed
-  // from the main entry for metrics purposes, and is true if the index was
-  // initialized when the open operation began.
-  int InitializeForOpen(bool had_index,
-                        SimpleEntryStat* out_entry_stat,
+  // Read the header and key at the beginning of the file, and validate that
+  // they are correct. If this entry was opened with a key, the key is checked
+  // for a match. If not, then the |key_| member is set based on the value in
+  // this header. Records histograms if any check is failed.
+  bool CheckHeaderAndKeyForOpen(int file_index);
+
+  // Returns a net error, i.e. net::OK on success.
+  int InitializeForOpen(SimpleEntryStat* out_entry_stat,
                         scoped_refptr<net::GrowableIOBuffer>* stream_0_data,
                         uint32_t* out_stream_0_crc32);
 
   // Writes the header and key to a newly-created stream file. |index| is the
   // index of the stream. Returns true on success; returns false and sets
   // |*out_result| on failure.
   bool InitializeCreatedFile(int index, CreateEntryResult* out_result);
 
   // Returns a net error, including net::OK on success and net::FILE_EXISTS
-  // when the entry already exists. |had_index| is passed from the main entry
-  // for metrics purposes, and is true if the index was initialized when the
-  // create operation began.
-  int InitializeForCreate(bool had_index, SimpleEntryStat* out_entry_stat);
+  // when the entry already exists.
+  int InitializeForCreate(SimpleEntryStat* out_entry_stat);
 
   // Allocates and fills a buffer with stream 0 data in |stream_0_data|, then
   // checks its crc32.
   int ReadAndValidateStream0(
       int total_data_size,
       SimpleEntryStat* out_entry_stat,
       scoped_refptr<net::GrowableIOBuffer>* stream_0_data,
       uint32_t* out_stream_0_crc32) const;
 
   int GetEOFRecordData(int index,
@@ skipping 48 matching lines @@
 
   base::FilePath GetFilenameFromFileIndex(int file_index);
 
   bool sparse_file_open() const {
     return sparse_file_.IsValid();
   }
 
   const net::CacheType cache_type_;
   const base::FilePath path_;
   const uint64_t entry_hash_;
+  const bool had_index_;
   std::string key_;
 
   bool have_open_files_;
   bool initialized_;
 
+  // Initially false, this is set to true when an entry is opened and the
+  // headers have not yet been checked. Any subsequent Read of data should
+  // validate them before completing.

[Randy Smith (Not in Mondays), 2016/05/17 20:04:08]

Suggestion: I'd find this comment more understandable in the context of the code
if it said ".. when an entry's headers are not checked at time of open ...". 
The phrasing above implies to me that they might have been checked at some point
before open, which I don't think is true or makes sense :-}.

[gavinp, 2016/05/18 15:46:01]

Done.

+  bool header_and_key_check_needed_;
+
   base::File files_[kSimpleEntryFileCount];
 
   // True if the corresponding stream is empty and therefore no on-disk file
   // was created to store it.
   bool empty_file_omitted_[kSimpleEntryFileCount];
 
   typedef std::map<int64_t, SparseRange> SparseRangeOffsetMap;
   typedef SparseRangeOffsetMap::iterator SparseRangeIterator;
   SparseRangeOffsetMap sparse_ranges_;
   base::File sparse_file_;
   // Offset of the end of the sparse file (where the next sparse range will be
   // written).
   int64_t sparse_tail_offset_;
 
   // True if the entry was created, or false if it was opened. Used to log
   // SimpleCache.*.EntryCreatedWithStream2Omitted only for created entries.
   bool files_created_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_