Adding new unit tests for HttpCache's OpenEntry, CreateEntry, and DoomEntry.

Change-Id: I3e14d19bef87a2f91d5cb7749afbd65a1c0323a3
Reviewed-on: https://chromium-review.googlesource.com/c/1452918Reviewed-by: Shivani Sharma <shivanisha@chromium.org>
Reviewed-by: Maks Orlovich <morlovich@chromium.org>
Commit-Queue: Steven Bingler <bingler@chromium.org>
Cr-Commit-Position: refs/heads/master@{#630561}

net/base/net_error_list.h

@@ -826,6 +826,9 @@ NET_ERROR(CACHE_AUTH_FAILURE_AFTER_READ, -410)
 // current configuration (e.g. load flags, mode, etc.)
 NET_ERROR(CACHE_ENTRY_NOT_SUITABLE, -411)
 
+// The disk cache is unable to doom this entry.
+NET_ERROR(CACHE_DOOM_FAILURE, -412)
+
 // The server's response was insecure (e.g. there was a cert error).
 NET_ERROR(INSECURE_RESPONSE, -501)
 

net/http/http_cache.h

@@ -58,7 +58,6 @@ class HttpNetworkSession;
 class HttpResponseInfo;
 class IOBuffer;
 class NetLog;
-class ViewCacheHelper;
 struct HttpRequestInfo;
 
 class NET_EXPORT HttpCache : public HttpTransactionFactory {
@@ -299,11 +298,11 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory {
   friend class TestHttpCacheTransaction;
   friend class TestHttpCache;
   friend class Transaction;
-  friend class ViewCacheHelper;
   struct PendingOp;  // Info for an entry under construction.
 
   // To help with testing.
   friend class MockHttpCache;
+  friend class HttpCacheTest;
 
   using TransactionList = std::list<Transaction*>;
   using TransactionSet = std::unordered_set<Transaction*>;

net/http/http_cache_transaction.h

@@ -115,6 +115,10 @@ class NET_EXPORT_PRIVATE HttpCache::Transaction : public HttpTransaction {
 
   const CompletionRepeatingCallback& io_callback() { return io_callback_; }
 
+  void SetIOCallBackForTest(CompletionRepeatingCallback cb) {
+    io_callback_ = cb;
+  }
+
   const NetLogWithSource& net_log() const;
 
   // Bypasses the cache lock whenever there is lock contention.

net/http/mock_http_cache.cc

@@ -414,6 +414,7 @@ MockDiskCache::MockDiskCache()
       double_create_check_(true),
       fail_sparse_requests_(false),
       support_in_memory_entry_data_(true),
+      force_fail_callback_later_(false),
       defer_op_(MockDiskEntry::DEFER_NONE),
       resume_return_code_(0) {}
 
@@ -434,6 +435,11 @@ net::Error MockDiskCache::OpenEntry(const std::string& key,
                                     disk_cache::Entry** entry,
                                     CompletionOnceCallback callback) {
   DCHECK(!callback.is_null());
+  if (force_fail_callback_later_) {
+    CallbackLater(std::move(callback), ERR_CACHE_OPEN_FAILURE);
+    return ERR_IO_PENDING;
+  }
+
   if (fail_requests_)
     return ERR_CACHE_OPEN_FAILURE;
 
@@ -471,6 +477,11 @@ net::Error MockDiskCache::CreateEntry(const std::string& key,
                                       disk_cache::Entry** entry,
                                       CompletionOnceCallback callback) {
   DCHECK(!callback.is_null());
+  if (force_fail_callback_later_) {
+    CallbackLater(std::move(callback), ERR_CACHE_CREATE_FAILURE);
+    return ERR_IO_PENDING;
+  }
+
   if (fail_requests_)
     return ERR_CACHE_CREATE_FAILURE;
 
@@ -525,6 +536,14 @@ net::Error MockDiskCache::DoomEntry(const std::string& key,
                                     net::RequestPriority request_priority,
                                     CompletionOnceCallback callback) {
   DCHECK(!callback.is_null());
+  if (force_fail_callback_later_) {
+    CallbackLater(std::move(callback), ERR_CACHE_DOOM_FAILURE);
+    return ERR_IO_PENDING;
+  }
+
+  if (fail_requests_)
+    return ERR_CACHE_DOOM_FAILURE;
+
   auto it = entries_.find(key);
   if (it != entries_.end()) {
     it->second->Release();

net/http/mock_http_cache.h

@@ -191,8 +191,8 @@ class MockDiskCache : public disk_cache::Backend {
   // Returns number of doomed entries.
   int doomed_count() const { return doomed_count_; }
 
-  // Fail any subsequent CreateEntry and OpenEntry.
-  void set_fail_requests() { fail_requests_ = true; }
+  // Fail any subsequent CreateEntry, OpenEntry, and DoomEntry
+  void set_fail_requests(bool value) { fail_requests_ = value; }
 
   // Return entries that fail some of their requests.
   void set_soft_failures(bool value) { soft_failures_ = value; }
@@ -212,6 +212,12 @@ class MockDiskCache : public disk_cache::Backend {
     support_in_memory_entry_data_ = value;
   }
 
+  // OpenEntry, CreateEntry, and DoomEntry immediately return with
+  // ERR_IO_PENDING and will callback some time later with an error.
+  void set_force_fail_callback_later(bool value) {
+    force_fail_callback_later_ = value;
+  }
+
   // Makes all requests for data ranges to fail as not implemented.
   void set_fail_sparse_requests() { fail_sparse_requests_ = true; }
 
@@ -256,6 +262,7 @@ class MockDiskCache : public disk_cache::Backend {
   bool double_create_check_;
   bool fail_sparse_requests_;
   bool support_in_memory_entry_data_;
+  bool force_fail_callback_later_;
 
   // Used for pause and restart.
   MockDiskEntry::DeferOp defer_op_;