SimpleCache: merge the first and second stream in one file

net/disk_cache/simple/simple_entry_impl.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_ENTRY_IMPL_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_
 
 #include <queue>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_entry_operation.h"
 
 namespace base {
 class TaskRunner;
 }
 
 namespace net {
+class GrowableIOBuffer;
 class IOBuffer;
 }
 
 namespace disk_cache {
 
 class SimpleBackendImpl;
 class SimpleSynchronousEntry;
 struct SimpleEntryStat;
 struct SimpleEntryCreationResults;
 
@@ skipping 172 matching lines @@
   void EntryOperationComplete(int stream_index,
                               const CompletionCallback& completion_callback,
                               const SimpleEntryStat& entry_stat,
                               scoped_ptr<int> result);
 
   // Called after an asynchronous read. Updates |crc32s_| if possible.
   void ReadOperationComplete(int stream_index,
                              int offset,
                              const CompletionCallback& completion_callback,
                              scoped_ptr<uint32> read_crc32,
-                             scoped_ptr<base::Time> last_used,
+                             scoped_ptr<SimpleEntryStat> entry_stat,
                              scoped_ptr<int> result);
 
   // Called after an asynchronous write completes.
   void WriteOperationComplete(int stream_index,
                               const CompletionCallback& completion_callback,
                               scoped_ptr<SimpleEntryStat> entry_stat,
                               scoped_ptr<int> result);
 
   // Called after an asynchronous doom completes.
   void DoomOperationComplete(const CompletionCallback& callback,
@@ skipping 13 matching lines @@
   // the entry in |entry_stat|. Updates the metadata in the entry and in the
   // index to make them available on next IO operations.
   void UpdateDataFromEntryStat(const SimpleEntryStat& entry_stat);
 
   int64 GetDiskUsage() const;
 
   // Used to report histograms.
   void RecordReadIsParallelizable(const SimpleEntryOperation& operation) const;
   void RecordWriteDependencyType(const SimpleEntryOperation& operation) const;
 
+  // Reads from the stream 0 data kept in memory.
+  int ReadStream0Data(net::IOBuffer* buf, int offset, int buf_len);
+
+  // Copies stream 0 data to the buffer kept in memory.
+  int CopyStream0Data(net::IOBuffer* buf,
+                      int offset, int buf_len,
+                      bool truncate);

[pasko, 2013/09/17 14:17:36]

since this function does not change the state of |buf|, it should be a const
reference. Also the comment is confusing, one might think that "the buffer kept
in memory" is |buf|. I would rephrase it like this: "Copies data from |buf| to
the internal in-memory buffer for stream 0."

nit: it would be useful to add a clarification that |truncate| if set to true
causes the target buffer to be truncated at |offset| before being written.

[clamy, 2013/09/18 16:17:14]

net::IOBuffer::data() is not const, and used in this function.

Done for the comment.

+
   // All nonstatic SimpleEntryImpl methods should always be called on the IO
   // thread, in all cases. |io_thread_checker_| documents and enforces this.
   base::ThreadChecker io_thread_checker_;
 
   const base::WeakPtr<SimpleBackendImpl> backend_;
   const net::CacheType cache_type_;
   const scoped_refptr<base::TaskRunner> worker_pool_;
   const base::FilePath path_;
   const uint64 entry_hash_;
   const bool use_optimistic_operations_;
   std::string key_;
 
   // |last_used_|, |last_modified_| and |data_size_| are copied from the
   // synchronous entry at the completion of each item of asynchronous IO.
   // TODO(clamy): Unify last_used_ with data in the index.
   base::Time last_used_;
   base::Time last_modified_;
-  int32 data_size_[kSimpleEntryFileCount];
+  int32 data_size_[kSimpleEntryStreamCount];
 
   // Number of times this object has been returned from Backend::OpenEntry() and
   // Backend::CreateEntry() without subsequent Entry::Close() calls. Used to
   // notify the backend when this entry not used by any callers.
   int open_count_;
 
   bool doomed_;
 
   State state_;
 
   // When possible, we compute a crc32, for the data in each entry as we read or
   // write. For each stream, |crc32s_[index]| is the crc32 of that stream from
   // [0 .. |crc32s_end_offset_|). If |crc32s_end_offset_[index] == 0| then the
   // value of |crc32s_[index]| is undefined.
-  int32 crc32s_end_offset_[kSimpleEntryFileCount];
-  uint32 crc32s_[kSimpleEntryFileCount];
+  int32 crc32s_end_offset_[kSimpleEntryStreamCount];
+  uint32 crc32s_[kSimpleEntryStreamCount];
 
   // If |have_written_[index]| is true, we have written to the stream |index|.

[Deprecated (see juliatuttle), 2013/09/16 20:01:52]

This comment is no longer strictly true; we set have_written_[0] if we write to
stream 1, since we will need to rewrite stream 1 also.

[clamy, 2013/09/17 13:59:42]

Done.

-  bool have_written_[kSimpleEntryFileCount];
+  bool have_written_[kSimpleEntryStreamCount];
 
   // Reflects how much CRC checking has been done with the entry. This state is
   // reported on closing each entry stream.
-  CheckCrcResult crc_check_state_[kSimpleEntryFileCount];
+  CheckCrcResult crc_check_state_[kSimpleEntryStreamCount];
 
   // The |synchronous_entry_| is the worker thread object that performs IO on
   // entries. It's owned by this SimpleEntryImpl whenever |executing_operation_|
   // is false (i.e. when an operation is not pending on the worker pool). When
   // an operation is being executed no one owns the synchronous entry. Therefore
   // SimpleEntryImpl should not be deleted while an operation is running as that
   // would leak the SimpleSynchronousEntry.
   SimpleSynchronousEntry* synchronous_entry_;
 
   std::queue<SimpleEntryOperation> pending_operations_;
 
   net::BoundNetLog net_log_;
 
   scoped_ptr<SimpleEntryOperation> executing_operation_;
+
+  // Unlike other streams, stream 0 data is read from the disk when the entry is
+  // opened, and then kept in memory. All read/write operations on stream 0
+  // affect the |stream_0_data_| buffer. When the entry is closed,
+  // |stream_0_data_| is written to the disk.
+  // Stream 0 is kept in memory because it is stored in the same file than

[pasko, 2013/09/17 14:17:36]

s/than/as/

s/(to save diskspace)// <-- since we also save on file the amount of open file
descriptors, which is arguably more important

[clamy, 2013/09/18 16:17:14]

Done.

+  // stream 1 on disk (to save diskspace). This strategy allows stream 1 to
+  // change size easily. Since stream 0 is only used to write HTTP headers, the
+  // memory consumption of keeping it in memory is acceptable.
+  scoped_refptr<net::GrowableIOBuffer> stream_0_data_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_