SimpleCache: open with fewer seeks.

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 678 matching lines @@
     return;
   }
 
   DCHECK_EQ(STATE_UNINITIALIZED, state_);
   DCHECK(!synchronous_entry_);
   state_ = STATE_IO_PENDING;
   const base::TimeTicks start_time = base::TimeTicks::Now();
   std::unique_ptr<SimpleEntryCreationResults> results(
       new SimpleEntryCreationResults(SimpleEntryStat(
           last_used_, last_modified_, data_size_, sparse_data_size_)));
-  Closure task = base::Bind(&SimpleSynchronousEntry::OpenEntry,
-                            cache_type_,
-                            path_,
-                            entry_hash_,
-                            have_index,
-                            results.get());
-  Closure reply = base::Bind(&SimpleEntryImpl::CreationOperationComplete,
-                             this,
-                             callback,
-                             start_time,
-                             base::Passed(&results),
-                             out_entry,
-                             net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_END);
+  Closure task =
+      base::Bind(&SimpleSynchronousEntry::OpenEntry, cache_type_, path_, key_,
+                 entry_hash_, have_index, results.get());
+  Closure reply =
+      base::Bind(&SimpleEntryImpl::CreationOperationComplete, this, callback,
+                 start_time, base::Passed(&results), out_entry,
+                 net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_END);
   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 }
 
 void SimpleEntryImpl::CreateEntryInternal(bool have_index,
                                           const CompletionCallback& callback,
                                           Entry** out_entry) {
   ScopedOperationRunner operation_runner(this);
 
   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_BEGIN);
 
@@ skipping 418 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 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. The key check in
-    // the open case is handled in SimpleBackendImpl.
+    // 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());
   }
   UpdateDataFromEntryStat(in_results->entry_stat);
   SIMPLE_CACHE_UMA(TIMES,
                    "EntryCreationTime", cache_type_,
                    (base::TimeTicks::Now() - start_time));
   AdjustOpenEntryCountBy(cache_type_, 1);
 
   net_log_.AddEvent(end_event_type);
   PostClientCallback(completion_callback, net::OK);
@@ skipping 231 matching lines @@
   }
   sparse_data_size_ = entry_stat.sparse_data_size();
   if (!doomed_ && backend_.get())
     backend_->index()->UpdateEntrySize(entry_hash_, GetDiskUsage());
 }
 
 int64_t SimpleEntryImpl::GetDiskUsage() const {
   int64_t file_size = 0;
   for (int i = 0; i < kSimpleEntryStreamCount; ++i) {
     file_size +=
-        simple_util::GetFileSizeFromKeyAndDataSize(key_, data_size_[i]);
+        simple_util::GetFileSizeFromDataSize(key_.size(), data_size_[i]);
   }
   file_size += sparse_data_size_;
   return file_size;
 }
 
 void SimpleEntryImpl::RecordReadIsParallelizable(
     const SimpleEntryOperation& operation) const {
   if (!executing_operation_)
     return;
   // Used in histograms, please only add entries at the end.
@@ skipping 135 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