[SimpleCache] Prefetch stream 1 so that the first read is faster

net/disk_cache/simple/simple_entry_impl.cc

 // 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.
 
 #include "net/disk_cache/simple/simple_entry_impl.h"
 
 #include <algorithm>
 #include <cstring>
 #include <limits>
 #include <utility>
@@ skipping 178 matching lines @@
       last_used_(Time::Now()),
       last_modified_(last_used_),
       sparse_data_size_(0),
       open_count_(0),
       doomed_(false),
       state_(STATE_UNINITIALIZED),
       synchronous_entry_(NULL),
       net_log_(
           net::NetLogWithSource::Make(net_log,
                                       net::NetLogSourceType::DISK_CACHE_ENTRY)),
-      stream_0_data_(new net::GrowableIOBuffer()) {
+      stream_0_data_(new net::GrowableIOBuffer()),
+      stream_1_prefetch_data_(new net::GrowableIOBuffer()) {
   static_assert(arraysize(data_size_) == arraysize(crc32s_end_offset_),
                 "arrays should be the same size");
   static_assert(arraysize(data_size_) == arraysize(crc32s_),
                 "arrays should be the same size");
   static_assert(arraysize(data_size_) == arraysize(have_written_),
                 "arrays should be the same size");
   static_assert(arraysize(data_size_) == arraysize(crc_check_state_),
                 "arrays should be the same size");
   MakeUninitialized();
   net_log_.BeginEvent(net::NetLogEventType::SIMPLE_CACHE_ENTRY,
@@ skipping 340 matching lines @@
   // I/O.  Therefore, CancelSparseIO and ReadyForSparseIO succeed instantly.
   return net::OK;
 }
 
 size_t SimpleEntryImpl::EstimateMemoryUsage() const {
   // TODO(xunjieli): crbug.com/669108. It'd be nice to have the rest of |entry|
   // measured, but the ownership of SimpleSynchronousEntry isn't straightforward
   return sizeof(SimpleSynchronousEntry) +
          base::trace_event::EstimateMemoryUsage(pending_operations_) +
          base::trace_event::EstimateMemoryUsage(executing_operation_) +
-         (stream_0_data_ ? stream_0_data_->capacity() : 0);
+         (stream_0_data_ ? stream_0_data_->capacity() : 0) +
+         (stream_1_prefetch_data_ ? stream_1_prefetch_data_->capacity() : 0);
 }
 
 SimpleEntryImpl::~SimpleEntryImpl() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(0U, pending_operations_.size());
   DCHECK(state_ == STATE_UNINITIALIZED || state_ == STATE_FAILURE);
   DCHECK(!synchronous_entry_);
   net_log_.EndEvent(net::NetLogEventType::SIMPLE_CACHE_ENTRY);
 }
 
@@ skipping 288 matching lines @@
   // Since stream 0 data is kept in memory, it is read immediately.
   if (stream_index == 0) {
     int ret_value = ReadStream0Data(buf, offset, buf_len);
     if (!callback.is_null()) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(callback, ret_value));
     }
     return;
   }
 
+  // XXX(jkarlin): See if we can use the prefetch data for stream 1.
+
   state_ = STATE_IO_PENDING;
   if (!doomed_ && backend_.get())
     backend_->index()->UseIfExists(entry_hash_);
 
   // Figure out if we should be computing the checksum for this read,
   // and whether we should be verifying it, too.
   std::unique_ptr<SimpleSynchronousEntry::CRCRequest> crc_request;
   if (crc32s_end_offset_[stream_index] == offset) {
     crc_request.reset(new SimpleSynchronousEntry::CRCRequest());
 
@@ skipping 275 matching lines @@
 
   state_ = STATE_READY;
   synchronous_entry_ = in_results->sync_entry;
   if (in_results->stream_0_data.get()) {
     stream_0_data_ = in_results->stream_0_data;
     // The crc was read in SimpleSynchronousEntry.
     crc_check_state_[0] = CRC_CHECK_DONE;
     crc32s_[0] = in_results->stream_0_crc32;
     crc32s_end_offset_[0] = in_results->entry_stat.data_size(0);
   }
+  if (in_results->stream_1_prefetch_data.get()) {
+    stream_1_prefetch_data_ = in_results->stream_1_prefetch_data;
+  }
+
   // If this entry was opened by hash, key_ could still be empty. If so, update
   // it with the key read from the synchronous entry.
   if (key_.empty()) {
     SetKey(synchronous_entry_->key());
   } else {
     // This should only be triggered when creating an entry. In the open case
     // the key is either copied from the arguments to open, or checked
     // in the synchronous entry.
     DCHECK_EQ(key_, synchronous_entry_->key());
   }
@@ skipping 354 matching lines @@
     }
     crc32s_end_offset_[stream_index] = offset + length;
   } else if (offset < crc32s_end_offset_[stream_index]) {
     // If a range for which the crc32 was already computed is rewritten, the
     // computation of the crc32 need to start from 0 again.
     crc32s_end_offset_[stream_index] = 0;
   }
 }
 
 }  // namespace disk_cache