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 35 matching lines @@
 #include "net/http/http_util.h"
 #include "net/log/net_log_with_source.h"
 #include "net/quic/chromium/quic_server_info.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 namespace net {
 
+namespace {
+
+void DoNothing(int rv) {}
+
+}  // anonymous namespace
+
 HttpCache::DefaultBackend::DefaultBackend(
     CacheType type,
     BackendType backend_type,
     const base::FilePath& path,
     int max_bytes,
     const scoped_refptr<base::SingleThreadTaskRunner>& thread)
     : type_(type),
       backend_type_(backend_type),
       path_(path),
       max_bytes_(max_bytes),
@@ skipping 666 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,
                          Transaction* trans) {
   ActiveEntry* active_entry = FindActiveEntry(key);
   if (active_entry) {
     *entry = active_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);
   if (pending_op->writer) {
     pending_op->pending_queue.push_back(std::move(item));
     return ERR_IO_PENDING;
   }
 
   DCHECK(pending_op->pending_queue.empty());
 
@@ skipping 418 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