DoomPartialEntry should not attempt to doom an already doomed entry.

net/http/mock_http_cache.h

 // Copyright (c) 2011 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.
 
 // This is a mock of the http cache and related testing classes. To be fair, it
 // is not really a mock http cache given that it uses the real implementation of
 // the http cache, but it has fake implementations of all required components,
 // so it is useful for unit tests at the http layer.
 
 #ifndef NET_HTTP_MOCK_HTTP_CACHE_H_
 #define NET_HTTP_MOCK_HTTP_CACHE_H_
 
 #include <stdint.h>
 
 #include <unordered_map>
 
 #include "base/strings/string_split.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_transaction_test_util.h"
 
 namespace net {
 
 //-----------------------------------------------------------------------------
 // Mock disk cache (a very basic memory cache implementation).
 
 class MockDiskEntry : public disk_cache::Entry,
                       public base::RefCounted<MockDiskEntry> {
  public:
+  // If |*defer| is set to true, the transaction will wait until
+  // ResumeCacheOperation is called before accessing the cache.
+  typedef base::Callback<void(bool* defer)> BeforeCacheOperationCallback;

[jkarlin, 2017/07/07 19:12:39]

Using instead of typedef

[jkarlin, 2017/07/07 19:12:39]

Instead of passing back a bool* defer (we always set it to true, so what's the
point?) why not have it pass back a continuation callback that the consumer can
run when it wants the Read to continue. That way MockHttpCache doesn't need to
keep track of doomed_entries_ and doesn't need the resume functions. WDYT?

[shivanisha, 2017/07/10 18:51:27]

MockHttpCache needs to keep track of doomed entries because MockDiskEntry is the
layer whose operation we are deferring so on resume, we should be able to
retrieve it and invoke Resume on it. Keeping track of doomed entries also help
in making IsDiskEntryDoomed return a better answer.

+
   explicit MockDiskEntry(const std::string& key);
 
   bool is_doomed() const { return doomed_; }
 
   void Doom() override;
   void Close() override;
   std::string GetKey() const override;
   base::Time GetLastUsed() const override;
   base::Time GetLastModified() const override;
   int32_t GetDataSize(int index) const override;
@@ skipping 27 matching lines @@
   // Fail most subsequent requests.
   void set_fail_requests() { fail_requests_ = true; }
 
   void set_fail_sparse_requests() { fail_sparse_requests_ = true; }
 
   // If |value| is true, don't deliver any completion callbacks until called
   // again with |value| set to false.  Caution: remember to enable callbacks
   // again or all subsequent tests will fail.
   static void IgnoreCallbacks(bool value);
 
+  // Sets the callback to be invoked before cache operation.
+  void SetBeforeCacheOperationCallback(

[jkarlin, 2017/07/07 19:12:39]

Name is too general, specifically this is for Reads. SetBeforeReadCallback?

[shivanisha, 2017/07/10 18:51:27]

Removed this for simplicity and using a DeferOp enum instead.

+      const BeforeCacheOperationCallback& callback);
+
+  // Resume deferred cache operation by posting |resume_callback_| with
+  // |resume_return_code_|. Returns ERR_IO_PENDING.
+  int ResumeCacheOperation();

[jkarlin, 2017/07/07 19:12:39]

BeforeCacheOperationCallback could be passed a callback to this method.

[shivanisha, 2017/07/10 18:51:27]

The latest changes probably make this not applicable.

+
  private:
   friend class base::RefCounted<MockDiskEntry>;
   struct CallbackInfo;
 
   ~MockDiskEntry() override;
 
   // Unlike the callbacks for MockHttpTransaction, we want this one to run even
   // if the consumer called Close on the MockDiskEntry.  We achieve that by
   // leveraging the fact that this class is reference counted.
   void CallbackLater(const CompletionCallback& callback, int result);
@@ skipping 12 matching lines @@
   std::string key_;
   std::vector<char> data_[kNumCacheEntryDataIndices];
   int test_mode_;
   bool doomed_;
   bool sparse_;
   bool fail_requests_;
   bool fail_sparse_requests_;
   bool busy_;
   bool delayed_;
   bool cancel_;
+
+  // TODO(shivanisha): Currently this is only used for ReadData. Extend to
+  // other cache operations as well.
+  BeforeCacheOperationCallback before_cache_callback_;
+  CompletionCallback resume_callback_;  // used for pause and restart.
+  int resume_return_code_;
+
   static bool ignore_callbacks_;
 };
 
 class MockDiskCache : public disk_cache::Backend {
  public:
   MockDiskCache();
   ~MockDiskCache() override;
 
   CacheType GetCacheType() const override;
   int32_t GetEntryCount() const override;
@@ skipping 34 matching lines @@
   // Makes sure that CreateEntry is not called twice for a given key.
   void set_double_create_check(bool value) { double_create_check_ = value; }
 
   // Makes all requests for data ranges to fail as not implemented.
   void set_fail_sparse_requests() { fail_sparse_requests_ = true; }
 
   void ReleaseAll();
 
   bool IsDiskEntryDoomed(const std::string& key);
 
+  // Add the cache operation callback to the entry.
+  void SetBeforeCacheOperationCallback(
+      const std::string& key,
+      const MockDiskEntry::BeforeCacheOperationCallback& callback);
+
+  // Resume deferred cache operation on entry with |key|.
+  int ResumeCacheOperation(const std::string& key);
+  int ResumeDoomedEntryCacheOperation(const std::string& key);
+
  private:
   using EntryMap = std::unordered_map<std::string, MockDiskEntry*>;
   class NotImplementedIterator;
 
   void CallbackLater(const CompletionCallback& callback, int result);
 
   EntryMap entries_;
+  EntryMap doomed_entries_;
   int open_count_;
   int create_count_;
   bool fail_requests_;
   bool soft_failures_;
   bool double_create_check_;
   bool fail_sparse_requests_;
 };
 
 class MockBackendFactory : public HttpCache::BackendFactory {
  public:
@@ skipping 53 matching lines @@
                           NetLog* net_log);
 
   // Returns the test mode after considering the global override.
   static int GetTestMode(int test_mode);
 
   // Overrides the test mode for a given operation. Remember to reset it after
   // the test! (by setting test_mode to zero).
   static void SetTestMode(int test_mode);
 
   // Functions to test the state of ActiveEntry.
-
   bool IsWriterPresent(const std::string& key);
   bool IsHeadersTransactionPresent(const std::string& key);
   int GetCountReaders(const std::string& key);
   int GetCountAddToEntryQueue(const std::string& key);
   int GetCountDoneHeadersQueue(const std::string& key);
 
  private:
   HttpCache http_cache_;
 };
 
@@ skipping 35 matching lines @@
 
   std::unique_ptr<disk_cache::Backend>* backend_;
   CompletionCallback callback_;
   bool block_;
   bool fail_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_MOCK_HTTP_CACHE_H_