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

net/disk_cache/simple/simple_synchronous_entry.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_synchronous_entry.h"
 
 #include <algorithm>
 #include <cstring>
 #include <functional>
 #include <limits>
@@ skipping 250 matching lines @@
     const base::TimeTicks& time_enqueued,
     SimpleEntryCreationResults* out_results) {
   base::TimeTicks start_sync_open_entry = base::TimeTicks::Now();
   SIMPLE_CACHE_UMA(TIMES, "QueueLatency.OpenEntry", cache_type,
                    (start_sync_open_entry - time_enqueued));
 
   SimpleSynchronousEntry* sync_entry =
       new SimpleSynchronousEntry(cache_type, path, key, entry_hash, had_index);
   out_results->result = sync_entry->InitializeForOpen(
       &out_results->entry_stat, &out_results->stream_0_data,
-      &out_results->stream_0_crc32);
+      &out_results->stream_0_crc32, &out_results->stream_1_prefetch_data);
   if (out_results->result != net::OK) {
     sync_entry->Doom();
     delete sync_entry;
-    out_results->sync_entry = NULL;
-    out_results->stream_0_data = NULL;
+    out_results->sync_entry = nullptr;
+    out_results->stream_0_data = nullptr;
+    out_results->stream_1_prefetch_data = nullptr;
     return;
   }
   SIMPLE_CACHE_UMA(TIMES, "DiskOpenLatency", cache_type,
                    base::TimeTicks::Now() - start_sync_open_entry);
   out_results->sync_entry = sync_entry;
 }
 
 // static
 void SimpleSynchronousEntry::CreateEntry(
     net::CacheType cache_type,
@@ skipping 785 matching lines @@
     }
   }
 
   header_and_key_check_needed_[file_index] = false;
   return true;
 }
 
 int SimpleSynchronousEntry::InitializeForOpen(
     SimpleEntryStat* out_entry_stat,
     scoped_refptr<net::GrowableIOBuffer>* stream_0_data,
-    uint32_t* out_stream_0_crc32) {
+    uint32_t* out_stream_0_crc32,
+    scoped_refptr<net::GrowableIOBuffer>* stream_1_prefetch_data) {
   DCHECK(!initialized_);
   if (!OpenFiles(out_entry_stat)) {
     DLOG(WARNING) << "Could not open platform files for entry.";
     return net::ERR_FAILED;
   }
+  bool iterator_open = false;
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     if (empty_file_omitted_[i])
       continue;
 
     if (key_.empty()) {
       // If |key_| is empty, we were opened via the iterator interface, without
       // knowing what our key is. We must therefore read the header immediately
       // to discover it, so SimpleEntryImpl can make it available to
       // disk_cache::Entry::GetKey().
+      iterator_open = true;
       if (!CheckHeaderAndKey(i))
         return net::ERR_FAILED;
     } else {
       // If we do know which key were are looking for, we still need to
       // check that the file actually has it (rather than just being a hash
       // collision or some sort of file system accident), but that can be put
       // off until opportune time: either the read of the footer, or when we
       // start reading in the data, depending on stream # and format revision.
       header_and_key_check_needed_[i] = true;
     }
@@ skipping 34 matching lines @@
     DeleteFileForEntryHash(path_, entry_hash_, stream2_file_index);
     empty_file_omitted_[stream2_file_index] = true;
     removed_stream2 = true;
   }
 
   SIMPLE_CACHE_UMA(BOOLEAN, "EntryOpenedAndStream2Removed", cache_type_,
                    removed_stream2);
 
   RecordSyncOpenResult(cache_type_, OPEN_ENTRY_SUCCESS, had_index_);
   initialized_ = true;
+
+  // If there is data to read and it's not partial, read some.
+  if (out_entry_stat->sparse_data_size() == 0 &&

[jkarlin, 2017/05/09 15:56:45]

The bits in this conditional are completely broken. Mostly cut and pastes that I
intended to hack into something.

+      out_entry_stat->data_size(1) > 0) {
+    // Figure out if we should be computing the checksum for this read,
+    // and whether we should be verifying it, too.
+    std::unique_ptr<CRCRequest> crc_request;
+    if (crc32s_end_offset_[stream_index] == 0) {
+      crc_request = base::MakeUnique<CRCRequest>();
+      crc_request->data_crc32 = crc32(0, Z_NULL, 0);
+      crc_request->request_verify = true;
+    }
+
+    std::unique_ptr<int> result = base::MakeUnique<int>(0);
+    std::unique_ptr<SimpleEntryStat> entry_stat =
+        base::MakeUnique<SimpleEntryStat>(last_used_, last_modified_,
+                                          data_size_, sparse_data_size_);
+    Closure task = base::Bind(&SimpleSynchronousEntry::ReadData,
+                              base::Unretained(synchronous_entry_),
+                              SimpleSynchronousEntry::EntryOperationData(
+                                  stream_index, offset, buf_len),
+                              crc_request.get(), entry_stat.get(),
+                              base::RetainedRef(buf), result.get());
+
+    ReadData
+  }
+
   return net::OK;
 }
 
 bool SimpleSynchronousEntry::InitializeCreatedFile(
     int file_index,
     CreateEntryResult* out_result) {
   SimpleFileHeader header;
   header.initial_magic_number = kSimpleInitialMagicNumber;
   header.version = kSimpleEntryVersionOnDisk;
 
@@ skipping 473 matching lines @@
   range.offset = offset;
   range.length = len;
   range.data_crc32 = data_crc32;
   range.file_offset = data_file_offset;
   sparse_ranges_.insert(std::make_pair(offset, range));
 
   return true;
 }
 
 }  // namespace disk_cache