Disk cache: Extend the internal buffering performed by each entry...

net/disk_cache/entry_impl.h

 // Copyright (c) 2006-2010 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_ENTRY_IMPL_H_
 #define NET_DISK_CACHE_ENTRY_IMPL_H_
 #pragma once
 
 #include "base/scoped_ptr.h"
 #include "net/disk_cache/disk_cache.h"
@@ skipping 115 matching lines @@
   // the upgrade tool.
   void SetTimes(base::Time last_used, base::Time last_modified);
 
   // Generates a histogram for the time spent working on this operation.
   void ReportIOTime(Operation op, const base::TimeTicks& start);
 
  private:
   enum {
      kNumStreams = 3
   };
+  class UserBuffer;
 
   ~EntryImpl();
 
   // Initializes the storage for an internal or external data block.
   bool CreateDataBlock(int index, int size);
 
   // Initializes the storage for an internal or external generic block.
   bool CreateBlock(int size, Addr* address);
 
   // Deletes the data pointed by address, maybe backed by files_[index].
   void DeleteData(Addr address, int index);
 
   // Updates ranking information.
   void UpdateRank(bool modified);
 
   // Returns a pointer to the file that stores the given address.
   File* GetBackingFile(Addr address, int index);
 
   // Returns a pointer to the file that stores external data.
   File* GetExternalFile(Addr address, int index);
 
   // Prepares the target file or buffer for a write of buf_len bytes at the
   // given offset.
   bool PrepareTarget(int index, int offset, int buf_len, bool truncate);
 
-  // Grows the size of the storage used to store user data, if needed.
-  bool GrowUserBuffer(int index, int offset, int buf_len, bool truncate);
+  // Adjusts the internal buffer and file handle for a write that truncates this
+  // stream.
+  bool HandleTruncation(int index, int offset, int buf_len);
+
+  // Copies data from disk to the internal buffer.
+  bool CopyToLocalBuffer(int index);
 
   // Reads from a block data file to this object's memory buffer.
   bool MoveToLocalBuffer(int index);
 
   // Loads the external file to this object's memory buffer.
-  bool ImportSeparateFile(int index, int offset, int buf_len);
+  bool ImportSeparateFile(int index, int new_size);
 
-  // Flush the in-memory data to the backing storage.
-  bool Flush(int index, int size, bool async);
+  // Makes sure that the internal buffer can handle the a write of |buf_len|
+  // bytes to |offset|.
+  bool PrepareBuffer(int index, int offset, int buf_len);
+
+  // Flushes the in-memory data to the backing storage.
+  bool Flush(int index);
+
+  // Updates the size of a given data stream.
+  void UpdateSize(int index, int old_size, int new_size);
 
   // Initializes the sparse control object. Returns a net error code.
   int InitSparseData();
 
   // Adds the provided |flags| to the current EntryFlags for this entry.
   void SetEntryFlags(uint32 flags);
 
   // Returns the current EntryFlags for this entry.
   uint32 GetEntryFlags();
 
   // Gets the data stored at the given index. If the information is in memory,
   // a buffer will be allocated and the data will be copied to it (the caller
   // can find out the size of the buffer before making this call). Otherwise,
   // the cache address of the data will be returned, and that address will be
   // removed from the regular book keeping of this entry so the caller is
   // responsible for deleting the block (or file) from the backing store at some
   // point; there is no need to report any storage-size change, only to do the
   // actual cleanup.
   void GetData(int index, char** buffer, Addr* address);
 
   // Logs this entry to the internal trace buffer.
   void Log(const char* msg);
 
   CacheEntryBlock entry_;     // Key related information for this entry.
   CacheRankingsBlock node_;   // Rankings related information for this entry.
   BackendImpl* backend_;      // Back pointer to the cache.
-  scoped_array<char> user_buffers_[kNumStreams];  // Store user data.
+  scoped_ptr<UserBuffer> user_buffers_[kNumStreams];  // Stores user data.
   // Files to store external user data and key.
   scoped_refptr<File> files_[kNumStreams + 1];
   mutable std::string key_;           // Copy of the key.
   int unreported_size_[kNumStreams];  // Bytes not reported yet to the backend.
   bool doomed_;               // True if this entry was removed from the cache.
   scoped_ptr<SparseControl> sparse_;  // Support for sparse entries.
 
   DISALLOW_COPY_AND_ASSIGN(EntryImpl);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_ENTRY_IMPL_H_