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

net/http/http_cache.cc

Index: net/http/http_cache.cc
diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc
index eaaffe48c1bf538768e39d46bd5505b71f7e0614..8bc0a5407e8e42cb88fb87292a070ade0b249185 100644
--- a/net/http/http_cache.cc
+++ b/net/http/http_cache.cc
@@ -53,6 +53,12 @@
 
 namespace net {
 
+namespace {
+
+void DoNothing(int rv) {}
+
+}  // anonymous namespace
+
 HttpCache::DefaultBackend::DefaultBackend(
     CacheType type,
     BackendType backend_type,
@@ -739,7 +745,8 @@ void HttpCache::DeletePendingOp(PendingOp* pending_op) {
   delete pending_op;
 }
 
-int HttpCache::OpenEntry(const std::string& key, ActiveEntry** entry,
+int HttpCache::OpenEntry(const std::string& key,
+                         ActiveEntry** entry,
                          Transaction* trans) {
   ActiveEntry* active_entry = FindActiveEntry(key);
   if (active_entry) {
@@ -747,6 +754,13 @@ int HttpCache::OpenEntry(const std::string& key, ActiveEntry** entry,
     return OK;
   }
 
+  // See if we could potentially quick-reject the entry.
+  uint8_t in_memory_info = disk_cache_->GetMemoryEntryData(key);
+  if (trans->CanRejectBasedOnMemoryEntryData(in_memory_info)) {
+    disk_cache_->DoomEntry(key, base::Bind(DoNothing));
+    return net::ERR_FAILED;

[Randy Smith (Not in Mondays), 2017/06/13 17:52:21]

Won't this result in failing the consuming HttpCache::Transacation/URLRequest? 
Don't we instead want to re-create the entry based on the
now-required-to-be-sent network request?

[Maks Orlovich, 2017/06/13 18:15:08]

It's the same status a miss on OpenEntry would return in the backend:

https://cs.chromium.org/chromium/src/net/disk_cache/simple/simple_entry_impl....
called from:
https://cs.chromium.org/chromium/src/net/disk_cache/simple/simple_backend_imp...

(And dooming the entry here is what prepares for the eventual CreateEntry to
succeed). 

There is an alternative approach I am sketching right now, though, and that's
basically to try to actually handle it in the state machine rather than treating
it as a miss. Advantages:
1) Way better at actually UMAing things.
2) Sets was_cached correctly so I think the higher-level stuff would work.
(The test failure I am getting are just reduction in open_count from cache, but
of course I only ran net_unittests)

Disadvantages:
1) It calls DoomEntry later.
2) Trying to fast-forward through the state machine is messy, and we are not
*really* in the same state as it would be, given the entry isn't actually read.
In general the whole thing ends up much harder to reason about, and I am not
even sure how to implement it cleanly (I ended up changing next_state_ directly
just to try it out).

I'll probably upload the ultra-dirty patch just so I could trybot it, but it's
likely I'll abandon that direction unless I can figure something out to refine
it.

+  }
+
   std::unique_ptr<WorkItem> item =
       base::MakeUnique<WorkItem>(WI_OPEN_ENTRY, trans, entry);
   PendingOp* pending_op = GetPendingOp(key);