Doom and create new entry when validation is not a match

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 960 matching lines @@
   if (entry->HasNoActiveTransactions() &&
       !entry->will_process_queued_transactions) {
     entry->disk_entry->Doom();
     RemoveAllQueuedTransactions(entry, &list);
     DestroyEntry(entry);
   } else {
     DoomActiveEntry(entry->disk_entry->GetKey());
     RemoveAllQueuedTransactions(entry, &list);
   }
   // ERR_CACHE_RACE causes the transaction to restart the whole process.
-  for (auto* transaction : list)
-    transaction->io_callback().Run(net::ERR_CACHE_RACE);
+  for (auto* transaction : list) {
+    // Post task here to avoid a race in case we are here because of the
+    // transaction that is dooming this entry and creating a new one because of
+    // validation not matching.
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(transaction->io_callback(), net::ERR_CACHE_RACE));

[Randy Smith (Not in Mondays), 2017/04/27 17:47:12]

Random thought, not for this CL: If we do this everywhere where we call the
io_callback(), would that let us switch over to a loop based approach for
managing the queues?  Maybe even just loop on the main thread, pushing callbacks
off until after we've done all state transitions?  We could even batch the
callbacks, queueing them up and then having a single post task that runs them
all after the queue processing is complete.

+  }
 }
 
 void HttpCache::ProcessQueuedTransactions(ActiveEntry* entry) {
   // Multiple readers may finish with an entry at once, so we want to batch up
   // calls to OnProcessQueuedTransactions. This flag also tells us that we
   // should not delete the entry before OnProcessQueuedTransactions runs.
   if (entry->will_process_queued_transactions)
     return;
 
   entry->will_process_queued_transactions = true;
@@ skipping 339 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