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

net/http/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/http_cache.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 721 matching lines @@
         pending_ops_.erase(it);
         break;
       }
     }
   }
   DCHECK(pending_op->pending_queue.empty());
 
   delete pending_op;
 }
 
-int HttpCache::OpenEntry(const std::string& key, ActiveEntry** entry,
+int HttpCache::OpenEntry(const std::string& key,
+                         ActiveEntry** entry,
+                         disk_cache::Backend::OracleCallback oracle_callback,
                          Transaction* trans) {
   ActiveEntry* active_entry = FindActiveEntry(key);
   if (active_entry) {
     *entry = active_entry;
     return OK;
   }
 
+  // ### store the oracle callback in this case?
   std::unique_ptr<WorkItem> item =
       base::MakeUnique<WorkItem>(WI_OPEN_ENTRY, trans, entry);
   PendingOp* pending_op = GetPendingOp(key);
   if (pending_op->writer) {
     pending_op->pending_queue.push_back(std::move(item));
     return ERR_IO_PENDING;
   }
 
   DCHECK(pending_op->pending_queue.empty());
 
   pending_op->writer = std::move(item);
   pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete,
                                     GetWeakPtr(), pending_op);
 
-  int rv = disk_cache_->OpenEntry(key, &(pending_op->disk_entry),
-                                  pending_op->callback);
+  int rv;
+  if (oracle_callback.is_null())
+    rv = disk_cache_->OpenEntry(key, &(pending_op->disk_entry),
+                                pending_op->callback);
+  else
+    rv = disk_cache_->OpenEntryWithOracleByte(
+        key, &(pending_op->disk_entry), oracle_callback, pending_op->callback);
   if (rv != ERR_IO_PENDING) {
     pending_op->writer->ClearTransaction();
     pending_op->callback.Run(rv);
   }
 
   return rv;
 }
 
 int HttpCache::CreateEntry(const std::string& key, ActiveEntry** entry,
                            Transaction* trans) {
@@ skipping 402 matching lines @@
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
   if (!item->DoCallback(result, disk_cache_.get()))
     item->NotifyTransaction(result, NULL);
 }
 
 }  // namespace net