DoomPartialEntry should not attempt to doom an already doomed entry.

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 56 matching lines @@
 };
 
 MockDiskEntry::MockDiskEntry(const std::string& key)
     : key_(key),
       doomed_(false),
       sparse_(false),
       fail_requests_(false),
       fail_sparse_requests_(false),
       busy_(false),
       delayed_(false),
-      cancel_(false) {
+      cancel_(false),
+      defer_op_(DEFER_NONE),
+      resume_return_code_(0) {
   test_mode_ = GetTestModeForEntry(key);
 }
 
 void MockDiskEntry::Doom() {
   doomed_ = true;
 }
 
 void MockDiskEntry::Close() {
   Release();
 }
@@ skipping 30 matching lines @@
     return ERR_FAILED;
   if (static_cast<size_t>(offset) == data_[index].size())
     return 0;
 
   int num = std::min(buf_len, static_cast<int>(data_[index].size()) - offset);
   memcpy(buf->data(), &data_[index][offset], num);
 
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_READ)
     return num;
 
+  // Pause and resume.
+  if (defer_op_ == DEFER_READ) {
+    defer_op_ = DEFER_NONE;
+    resume_callback_ = callback;
+    resume_return_code_ = num;
+    return ERR_IO_PENDING;
+  }
+
   CallbackLater(callback, num);
   return ERR_IO_PENDING;
 }
 
+int MockDiskEntry::ResumeCacheOperation() {
+  DCHECK(!resume_callback_.is_null());
+  CallbackLater(resume_callback_, resume_return_code_);
+  resume_callback_.Reset();
+  resume_return_code_ = 0;
+  return ERR_IO_PENDING;
+}
+
 int MockDiskEntry::WriteData(int index,
                              int offset,
                              IOBuffer* buf,
                              int buf_len,
                              const CompletionCallback& callback,
                              bool truncate) {
   DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
   DCHECK(!callback.is_null());
   DCHECK(truncate);
 
@@ skipping 227 matching lines @@
 
 //-----------------------------------------------------------------------------
 
 MockDiskCache::MockDiskCache()
     : open_count_(0),
       create_count_(0),
       doomed_count_(0),
       fail_requests_(false),
       soft_failures_(false),
       double_create_check_(true),
-      fail_sparse_requests_(false) {}
+      fail_sparse_requests_(false),
+      defer_op_(DEFER_NONE),
+      resume_return_code_(0) {}
 
 MockDiskCache::~MockDiskCache() {
   ReleaseAll();
 }
 
 CacheType MockDiskCache::GetCacheType() const {
   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) {
   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 (it->second->is_doomed()) {
-    it->second->Release();
+    // It's possible that the entry was doomed directly by invoking

[jkarlin, 2017/07/12 16:15:54]

There is a lot of new code here to track doomed entries so that they can later
be resumed by the test.

This is why I suggested that when setting the defer, the test passes a callback.
The entry can then run the callback and pass the test a closure to run when the
test wants the entry to resume. The closure would have a ref to the entry and
run the resume function.

That way the MockDiskCache doesn't need to keep track of doomed entries since
the test calls the entry directly.

[shivanisha, 2017/07/12 17:56:31]

Keeping track of doomed_entries seems kind of good to have. The passing of entry
to the test seems to require more work in the test for every defer-resume and
less consistent in terms of layering since it passes an entry reference back to
the test. WDYT?

[shivanisha, 2017/07/13 14:47:26]

Let me know if you prefer to have the closure approach or the doomed_entries_
approach is fine.

+    // MockDiskEntry::Doom and thus was not inserted into the doomed_entries_
+    // map. Insert it now.
+    if (doomed_entries_.count(key))
+      doomed_entries_[key]->Release();
+    doomed_entries_[key] = it->second;
     entries_.erase(it);
     return ERR_CACHE_OPEN_FAILURE;
   }
 
   open_count_++;
 
   it->second->AddRef();
   *entry = it->second;
 
   if (soft_failures_)
@@ skipping 14 matching lines @@
     return ERR_CACHE_CREATE_FAILURE;
 
   EntryMap::iterator it = entries_.find(key);
   if (it != entries_.end()) {
     if (!it->second->is_doomed()) {
       if (double_create_check_)
         NOTREACHED();
       else
         return ERR_CACHE_CREATE_FAILURE;
     }
-    it->second->Release();
+    // It's possible that the entry was doomed directly by invoking
+    // MockDiskEntry::Doom and thus was not inserted into the doomed_entries_
+    // map. Insert it now.
+    if (doomed_entries_.count(key))
+      doomed_entries_[key]->Release();
+    doomed_entries_[key] = it->second;
     entries_.erase(it);
   }
 
   create_count_++;
 
   MockDiskEntry* new_entry = new MockDiskEntry(key);
 
   new_entry->AddRef();
   entries_[key] = new_entry;
 
   new_entry->AddRef();
   *entry = new_entry;
 
   if (soft_failures_)
     new_entry->set_fail_requests();
 
   if (fail_sparse_requests_)
     new_entry->set_fail_sparse_requests();
 
   if (GetTestModeForEntry(key) & TEST_MODE_SYNC_CACHE_START)
     return OK;
 
+  // Pause and resume.
+  if (defer_op_ == DEFER_CREATE) {
+    defer_op_ = DEFER_NONE;
+    resume_callback_ = callback;
+    resume_return_code_ = OK;
+    return ERR_IO_PENDING;
+  }
+
   CallbackLater(callback, OK);
   return ERR_IO_PENDING;
 }
 
 int MockDiskCache::DoomEntry(const std::string& key,
                              const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   EntryMap::iterator it = entries_.find(key);
   if (it != entries_.end()) {
-    it->second->Release();
+    if (doomed_entries_.count(key))
+      doomed_entries_[key]->Release();
+    doomed_entries_[key] = it->second;
     entries_.erase(it);
     doomed_count_++;
   }
 
   if (GetTestModeForEntry(key) & TEST_MODE_SYNC_CACHE_START)
     return OK;
 
   CallbackLater(callback, OK);
   return ERR_IO_PENDING;
 }
@@ skipping 36 matching lines @@
 void MockDiskCache::OnExternalCacheHit(const std::string& key) {
 }
 
 size_t MockDiskCache::DumpMemoryStats(
     base::trace_event::ProcessMemoryDump* pmd,
     const std::string& parent_absolute_name) const {
   return 0u;
 }
 
 void MockDiskCache::ReleaseAll() {
-  EntryMap::iterator it = entries_.begin();
-  for (; it != entries_.end(); ++it)
-    it->second->Release();
+  for (auto entry : entries_)
+    entry.second->Release();
   entries_.clear();
+
+  for (auto doomed : doomed_entries_)
+    doomed.second->Release();
+  doomed_entries_.clear();
 }
 
 void MockDiskCache::CallbackLater(const CompletionCallback& callback,
                                   int result) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&CallbackForwader, callback, result));
 }
 
 bool MockDiskCache::IsDiskEntryDoomed(const std::string& key) {
+  auto doomed_it = doomed_entries_.find(key);
+  if (doomed_it != doomed_entries_.end())
+    return true;
+
+  auto it = entries_.find(key);
+  if (it != entries_.end())
+    return it->second->is_doomed();
+
+  return false;
+}
+
+bool MockDiskCache::IsDiskEntryNotDoomed(const std::string& key) {
+  auto it = entries_.find(key);
+  if (it != entries_.end())
+    return !it->second->is_doomed();
+
+  return false;
+}
+
+int MockDiskCache::ResumeCacheOperation() {
+  DCHECK(!resume_callback_.is_null());
+  CallbackLater(resume_callback_, resume_return_code_);
+  resume_callback_.Reset();
+  resume_return_code_ = 0;
+  return ERR_IO_PENDING;
+}
+
+void MockDiskCache::SetDefer(const std::string& key, const DeferOp defer_op) {
   auto it = entries_.find(key);
   if (it == entries_.end())
-    return false;
-  return it->second->is_doomed();
+    return;
+  it->second->SetDefer(defer_op);
+}
+
+int MockDiskCache::ResumeCacheOperation(const std::string& key) {
+  auto it = entries_.find(key);
+  if (it != entries_.end())
+    return it->second->ResumeCacheOperation();
+
+  return ERR_UNEXPECTED;
+}
+
+int MockDiskCache::ResumeDoomedEntryCacheOperation(const std::string& key) {
+  auto doomed_it = doomed_entries_.find(key);
+  if (doomed_it != doomed_entries_.end())
+    return doomed_it->second->ResumeCacheOperation();
+
+  auto it = entries_.find(key);
+  if (it != entries_.end()) {
+    DCHECK(it->second->is_doomed());
+    return it->second->ResumeCacheOperation();
+  }
+
+  return ERR_UNEXPECTED;
 }
 
 //-----------------------------------------------------------------------------
 
 int MockBackendFactory::CreateBackend(
     NetLog* net_log,
     std::unique_ptr<disk_cache::Backend>* backend,
     const CompletionCallback& callback) {
   backend->reset(new MockDiskCache());
   return OK;
@@ skipping 190 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