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

net/disk_cache/sparse_control.h

 // Copyright (c) 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.
 
 #ifndef NET_DISK_CACHE_SPARSE_CONTROL_H_
 #define NET_DISK_CACHE_SPARSE_CONTROL_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 63 matching lines @@
   int CreateSparseEntry();
   int OpenSparseEntry(int data_len);
 
   // Opens and closes a child entry. A child entry is a regular EntryImpl object
   // with a key derived from the key of the resource to store and the range
   // stored by that child.
   bool OpenChild();
   void CloseChild();
   std::string GenerateChildKey();
 
+  // Deletes the current child and continues the current operation (open).
+  bool KillChildAndContinue(const std::string& key, bool fatal);
+
+  // Continues the current operation (open) without a current child.
+  bool ContinueWithoutChild(const std::string& key);
+
   // Returns true if the required child is tracked by the parent entry, i.e. it
   // was already created.
   bool ChildPresent();
 
-  // Starts tracking this child. A new child entry was created so we must set
-  // the corresponding bit on the bitmap of children.
-  void SetChildBit();
+  // Sets the bit for the current child to the provided |value|. In other words,
+  // starts or stops tracking this child.
+  void SetChildBit(bool value);
 
   // Writes to disk the tracking information for this entry.
   void WriteSparseData();
 
   // Verify that the range to be accessed for the current child is appropriate.
   // Returns false if an error is detected or there is no need to perform the
   // current IO operation (for instance if the required range is not stored by
   // the child).
   bool VerifyRange();
 
   // Updates the contents bitmap for the current range, based on the result of
   // the current operation.
   void UpdateRange(int result);
 
+  // Returns the number of bytes stored at |block_index|, if its allocation-bit
+  // is off (because it is not completely filled).
+  int PartialBlockLength(int block_index) const;
+
   // Initializes the sparse info for the current child.
   void InitChildData();
 
   // Iterates through all the children needed to complete the current operation.
   void DoChildrenIO();
 
   // Performs a single operation with the current child. Returns true when we
   // should move on to the next child and false when we should interrupt our
   // work.
   bool DoChildIO();
@@ skipping 31 matching lines @@
   int child_offset_;  // Offset to use for the current child.
   int child_len_;  // Bytes to read or write for this child.
   int result_;
 
   DISALLOW_COPY_AND_ASSIGN(SparseControl);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SPARSE_CONTROL_H_