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

net/http/mock_http_cache.cc

 // Copyright (c) 2012 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/http/mock_http_cache.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 50 matching lines @@
 //-----------------------------------------------------------------------------
 
 struct MockDiskEntry::CallbackInfo {
   scoped_refptr<MockDiskEntry> entry;
   CompletionCallback callback;
   int result;
 };
 
 MockDiskEntry::MockDiskEntry(const std::string& key)
     : key_(key),
+      oracle_byte_(0),
       doomed_(false),
       sparse_(false),
       fail_requests_(false),
       fail_sparse_requests_(false),
       busy_(false),
       delayed_(false),
       cancel_(false) {
   test_mode_ = GetTestModeForEntry(key);
 }
 
@@ skipping 10 matching lines @@
 }
 
 base::Time MockDiskEntry::GetLastUsed() const {
   return base::Time::Now();
 }
 
 base::Time MockDiskEntry::GetLastModified() const {
   return base::Time::Now();
 }
 
+void MockDiskEntry::SetOracleByte(uint8_t val) {
+  oracle_byte_ = val;
+}
+
 int32_t MockDiskEntry::GetDataSize(int index) const {
   DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
   return static_cast<int32_t>(data_[index].size());
 }
 
 int MockDiskEntry::ReadData(int index,
                             int offset,
                             IOBuffer* buf,
                             int buf_len,
                             const CompletionCallback& callback) {
@@ skipping 272 matching lines @@
   return DISK_CACHE;
 }
 
 int32_t MockDiskCache::GetEntryCount() const {
   return static_cast<int32_t>(entries_.size());
 }
 
 int MockDiskCache::OpenEntry(const std::string& key,
                              disk_cache::Entry** entry,
                              const CompletionCallback& callback) {
+  return OpenEntryWithOracleByte(key, entry, OracleCallback(), callback);
+}
+
+int MockDiskCache::OpenEntryWithOracleByte(const std::string& key,
+                                           disk_cache::Entry** entry,
+                                           const OracleCallback& oracle,
+                                           const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (fail_requests_)
     return ERR_CACHE_OPEN_FAILURE;
 
   EntryMap::iterator it = entries_.find(key);
   if (it == entries_.end())
     return ERR_CACHE_OPEN_FAILURE;
 
+  if (!oracle.is_null() && oracle.Run(it->second->GetOracleByte()) ==
+                               Backend::OracleJudgement::MISS_AND_DOOM) {
+    it->second->Doom();
+    // Will be handled immediately below.
+  }
+
   if (it->second->is_doomed()) {
     it->second->Release();
     entries_.erase(it);
     return ERR_CACHE_OPEN_FAILURE;
   }
 
   open_count_++;
 
   it->second->AddRef();
   *entry = it->second;
@@ skipping 285 matching lines @@
   if (!callback_.is_null()) {
     if (!fail_)
       backend_->reset(new MockDiskCache());
     CompletionCallback cb = callback_;
     callback_.Reset();
     cb.Run(Result());  // This object can be deleted here.
   }
 }
 
 }  // namespace net