Simple Cache: avoid extraneous stream 0 (http header) writes.

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 669 matching lines @@
     return;
   }
   RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_SUCCESS);
 }
 
 void SimpleSynchronousEntry::Close(
     const SimpleEntryStat& entry_stat,
     std::unique_ptr<std::vector<CRCRecord>> crc32s_to_write,
     net::GrowableIOBuffer* stream_0_data) {
   DCHECK(stream_0_data);
-  // Write stream 0 data.
-  int stream_0_offset = entry_stat.GetOffsetInFile(key_.size(), 0, 0);
-  if (files_[0].Write(stream_0_offset, stream_0_data->data(),
-                      entry_stat.data_size(0)) !=
-      entry_stat.data_size(0)) {
-    RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE);
-    DVLOG(1) << "Could not write stream 0 data.";
-    Doom();
-  }
-  net::SHA256HashValue hash_value;
-  CalculateSHA256OfKey(key_, &hash_value);
-  if (files_[0].Write(stream_0_offset + entry_stat.data_size(0),
-                      reinterpret_cast<char*>(hash_value.data),
-                      sizeof(hash_value)) != sizeof(hash_value)) {
-    RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE);
-    DVLOG(1) << "Could not write stream 0 data.";
-    Doom();
-  }
 
   for (std::vector<CRCRecord>::const_iterator it = crc32s_to_write->begin();
        it != crc32s_to_write->end(); ++it) {
     const int stream_index = it->index;
     const int file_index = GetFileIndexFromStreamIndex(stream_index);
     if (empty_file_omitted_[file_index])
       continue;
 
+    if (stream_index == 0) {
+      // Write stream 0 data.
+      int stream_0_offset = entry_stat.GetOffsetInFile(key_.size(), 0, 0);
+      if (files_[0].Write(stream_0_offset, stream_0_data->data(),
+                          entry_stat.data_size(0)) != entry_stat.data_size(0)) {
+        RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE);
+        DVLOG(1) << "Could not write stream 0 data.";
+        Doom();
+      }
+      net::SHA256HashValue hash_value;
+      CalculateSHA256OfKey(key_, &hash_value);
+      if (files_[0].Write(stream_0_offset + entry_stat.data_size(0),
+                          reinterpret_cast<char*>(hash_value.data),
+                          sizeof(hash_value)) != sizeof(hash_value)) {
+        RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE);
+        DVLOG(1) << "Could not write stream 0 data.";
+        Doom();
+      }
+    }
+
     SimpleFileEOF eof_record;
     eof_record.stream_size = entry_stat.data_size(stream_index);
     eof_record.final_magic_number = kSimpleFinalMagicNumber;
     eof_record.flags = 0;
     if (it->has_crc32)
       eof_record.flags |= SimpleFileEOF::FLAG_HAS_CRC32;
     if (stream_index == 0)
       eof_record.flags |= SimpleFileEOF::FLAG_HAS_KEY_SHA256;
     eof_record.data_crc32 = it->data_crc32;
     int eof_offset = entry_stat.GetEOFOffsetInFile(key_.size(), stream_index);
@@ skipping 861 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