Disk cache: Add support for having a sparse entry block that...

net/disk_cache/disk_format.h

 // Copyright (c) 2006-2009 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.
 
 // The cache is stored on disk as a collection of block-files, plus an index
 // file plus a collection of external files.
 //
 // Any data blob bigger than kMaxBlockSize (net/addr.h) will be stored on a
 // separate file named f_xxx where x is a hexadecimal number. Shorter data will
 // be stored as a series of blocks on a block-file. In any case, CacheAddr
@@ skipping 215 matching lines @@
 //
 // Each child entry keeps track of all the 1 KB blocks that have been written
 // to the entry, but being a regular entry, it will happily return zeros for any
 // read that spans data not written before. The actual sparse data is stored in
 // one of the data streams of the child entry (at index 1), while the control
 // information is stored in another stream (at index 2), both by parents and
 // the children.
 
 // This structure contains the control information for parent and child entries.
 // It is stored at offset 0 of the data stream with index 2.
+// It is possible to write to a child entry in a way that causes the last block
+// to be only partialy filled. In that case, last_block and last_block_len will
+// keep track of that block.
 struct SparseHeader {
   int64 signature;          // The parent and children signature.
   uint32 magic;             // Structure identifier (equal to kIndexMagic).
   int32 parent_key_len;     // Key length for the parent entry.
-  int32 dummy[4];
+  int32 last_block;         // Index of the last written block.
+  int32 last_block_len;     // Lenght of the last written block.
+  int32 dummy[10];
 };
 
 // The SparseHeader will be followed by a bitmap, as described by this
 // structure.
 struct SparseData {
   SparseHeader header;
   uint32 bitmap[32];        // Bitmap representation of known children (if this
                             // is a parent entry), or used blocks (for child
                             // entries. The size is fixed for child entries but
                             // not for parents; it can be as small as 4 bytes
                             // and as large as 8 KB.
 };
 
 // The number of blocks stored by a child entry.
 const int kNumSparseBits = 1024;
 COMPILE_ASSERT(sizeof(SparseData) == sizeof(SparseHeader) + kNumSparseBits / 8,
                Invalid_SparseData_bitmap);
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_FORMAT_H_