RFC: use some in-memory state in SimpleCache to quickly cache-miss some CantConditionalize cases

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 187 matching lines @@
                       CreateNetLogSimpleEntryConstructionCallback(this));
 }
 
 void SimpleEntryImpl::SetActiveEntryProxy(
     std::unique_ptr<ActiveEntryProxy> active_entry_proxy) {
   DCHECK(!active_entry_proxy_);
   active_entry_proxy_ = std::move(active_entry_proxy);
 }
 
 int SimpleEntryImpl::OpenEntry(Entry** out_entry,
+                               const Backend::OracleCallback& oracle,
                                const CompletionCallback& callback) {
   DCHECK(backend_.get());
 
   net_log_.AddEvent(net::NetLogEventType::SIMPLE_CACHE_ENTRY_OPEN_CALL);
 
   bool have_index = backend_->index()->initialized();
   // This enumeration is used in histograms, add entries only at end.
   enum OpenEntryIndexEnum {
     INDEX_NOEXIST = 0,
     INDEX_MISS = 1,
     INDEX_HIT = 2,
     INDEX_MAX = 3,
   };
   OpenEntryIndexEnum open_entry_index_enum = INDEX_NOEXIST;
+  uint8_t oracle_byte = 0;
   if (have_index) {
-    if (backend_->index()->Has(entry_hash_))
+    if (backend_->index()->HasWithOracleByte(entry_hash_, &oracle_byte))
       open_entry_index_enum = INDEX_HIT;
     else
       open_entry_index_enum = INDEX_MISS;
   }
   SIMPLE_CACHE_UMA(ENUMERATION,
                    "OpenEntryIndexState", cache_type_,
                    open_entry_index_enum, INDEX_MAX);
 
+  if (open_entry_index_enum == INDEX_HIT && !oracle.is_null() &&
+      oracle.Run(oracle_byte) == Backend::OracleJudgement::MISS_AND_DOOM) {
+    // ### UMA this.
+    // ### net log.
+    Doom();
+    return net::ERR_FAILED;
+  }
+
   // If entry is not known to the index, initiate fast failover to the network.
   if (open_entry_index_enum == INDEX_MISS) {
     net_log_.AddEventWithNetErrorCode(
         net::NetLogEventType::SIMPLE_CACHE_ENTRY_OPEN_END, net::ERR_FAILED);
     return net::ERR_FAILED;
   }
 
   pending_operations_.push(SimpleEntryOperation::OpenOperation(
       this, have_index, callback, out_entry));
   RunNextOperationIfNeeded();
@@ skipping 1114 matching lines @@
   for (int i = 0; i < kSimpleEntryStreamCount; ++i) {
     data_size_[i] = entry_stat.data_size(i);
   }
   sparse_data_size_ = entry_stat.sparse_data_size();
   if (!doomed_ && backend_.get()) {
     backend_->index()->UpdateEntrySize(
         entry_hash_, base::checked_cast<uint32_t>(GetDiskUsage()));
   }
 }
 
+void SimpleEntryImpl::SetOracleByte(uint8_t oracle_byte) {
+  DCHECK(io_thread_checker_.CalledOnValidThread());
+  if (!doomed_ && backend_.get()) {
+    backend_->index()->UpdateEntryOracleByte(entry_hash_, oracle_byte);
+  }
+}
+
 int64_t SimpleEntryImpl::GetDiskUsage() const {
   int64_t file_size = 0;
   for (int i = 0; i < kSimpleEntryStreamCount; ++i) {
     file_size +=
         simple_util::GetFileSizeFromDataSize(key_.size(), data_size_[i]);
   }
   file_size += sparse_data_size_;
   return file_size;
 }
 
@@ skipping 140 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