Merge 22701 - Http Cache: Deactivate entries without having the key of the...

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2009 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 "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
@@ skipping 12 matching lines @@
 
 namespace {
 
 //-----------------------------------------------------------------------------
 // mock disk cache (a very basic memory cache implementation)
 
 class MockDiskEntry : public disk_cache::Entry,
                       public base::RefCounted<MockDiskEntry> {
  public:
   MockDiskEntry()
-      : test_mode_(0), doomed_(false), sparse_(false) {
+      : test_mode_(0), doomed_(false), sparse_(false), fail_requests_(false) {
   }
 
   explicit MockDiskEntry(const std::string& key)
-      : key_(key), doomed_(false), sparse_(false) {
+      : key_(key), doomed_(false), sparse_(false), fail_requests_(false) {
     //
     // 'key' is prefixed with an identifier if it corresponds to a cached POST.
     // Skip past that to locate the actual URL.
     //
     // TODO(darin): It breaks the abstraction a bit that we assume 'key' is an
     // URL corresponding to a registered MockTransaction.  It would be good to
     // have another way to access the test_mode.
     //
     GURL url;
     if (isdigit(key[0])) {
@@ skipping 15 matching lines @@
 
   virtual void Doom() {
     doomed_ = true;
   }
 
   virtual void Close() {
     Release();
   }
 
   virtual std::string GetKey() const {
+    if (fail_requests_)
+      return std::string();
     return key_;
   }
 
   virtual Time GetLastUsed() const {
     return Time::FromInternalValue(0);
   }
 
   virtual Time GetLastModified() const {
     return Time::FromInternalValue(0);
   }
 
   virtual int32 GetDataSize(int index) const {
     DCHECK(index >= 0 && index < 2);
     return static_cast<int32>(data_[index].size());
   }
 
   virtual int ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
                        net::CompletionCallback* callback) {
     DCHECK(index >= 0 && index < 2);
 
+    if (fail_requests_)
+      return net::ERR_CACHE_READ_FAILURE;
+
     if (offset < 0 || offset > static_cast<int>(data_[index].size()))
       return net::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 (!callback || (test_mode_ & TEST_MODE_SYNC_CACHE_READ))
       return num;
 
     CallbackLater(callback, num);
     return net::ERR_IO_PENDING;
   }
 
   virtual int WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
                         net::CompletionCallback* callback, bool truncate) {
     DCHECK(index >= 0 && index < 2);
     DCHECK(truncate);
 
+    if (fail_requests_)
+      return net::ERR_CACHE_READ_FAILURE;
+
     if (offset < 0 || offset > static_cast<int>(data_[index].size()))
       return net::ERR_FAILED;
 
     data_[index].resize(offset + buf_len);
     if (buf_len)
       memcpy(&data_[index][offset], buf->data(), buf_len);
     return buf_len;
   }
 
   virtual int ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
                              net::CompletionCallback* completion_callback) {
     if (!sparse_)
       return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
     if (offset < 0)
       return net::ERR_FAILED;
 
+    if (fail_requests_)
+      return net::ERR_CACHE_READ_FAILURE;
+
     DCHECK(offset < kint32max);
     int real_offset = static_cast<int>(offset);
     if (!buf_len)
       return 0;
 
     int num = std::min(static_cast<int>(data_[1].size()) - real_offset,
                        buf_len);
     memcpy(buf->data(), &data_[1][real_offset], num);
 
     if (!completion_callback || (test_mode_ & TEST_MODE_SYNC_CACHE_READ))
       return num;
 
     CallbackLater(completion_callback, num);
     return net::ERR_IO_PENDING;
   }
 
   virtual int WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
                               net::CompletionCallback* completion_callback) {
     if (!sparse_) {
       if (data_[1].size())
         return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
       sparse_ = true;
     }
     if (offset < 0)
       return net::ERR_FAILED;
     if (!buf_len)
       return 0;
 
+    if (fail_requests_)
+      return net::ERR_CACHE_READ_FAILURE;
+
     DCHECK(offset < kint32max);
     int real_offset = static_cast<int>(offset);
 
     if (static_cast<int>(data_[1].size()) < real_offset + buf_len)
       data_[1].resize(real_offset + buf_len);
 
     memcpy(&data_[1][real_offset], buf->data(), buf_len);
     return buf_len;
   }
 
   virtual int GetAvailableRange(int64 offset, int len, int64* start) {
     if (!sparse_)
       return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
     if (offset < 0)
       return net::ERR_FAILED;
 
+    if (fail_requests_)
+      return net::ERR_CACHE_READ_FAILURE;
+
     *start = offset;
     DCHECK(offset < kint32max);
     int real_offset = static_cast<int>(offset);
     if (static_cast<int>(data_[1].size()) < real_offset)
       return 0;
 
     int num = std::min(static_cast<int>(data_[1].size()) - real_offset, len);
     int count = 0;
     for (; num > 0; num--, real_offset++) {
       if (!count) {
         if (data_[1][real_offset]) {
           count++;
           *start = real_offset;
         }
       } else {
         if (!data_[1][real_offset])
           break;
         count++;
       }
     }
     return count;
   }
 
+  // Fail most subsequent requests.
+  void set_fail_requests() { fail_requests_ = true; }
+
  private:
   // 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(net::CompletionCallback* callback, int result) {
     MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(this,
         &MockDiskEntry::RunCallback, callback, result));
   }
   void RunCallback(net::CompletionCallback* callback, int result) {
     callback->Run(result);
   }
 
   std::string key_;
   std::vector<char> data_[2];
   int test_mode_;
   bool doomed_;
   bool sparse_;
+  bool fail_requests_;
 };
 
 class MockDiskCache : public disk_cache::Backend {
  public:
-  MockDiskCache() : open_count_(0), create_count_(0), fail_requests_(0) {
+  MockDiskCache()
+      : open_count_(0), create_count_(0), fail_requests_(false),
+        soft_failures_(false) {
   }
 
   ~MockDiskCache() {
     EntryMap::iterator it = entries_.begin();
     for (; it != entries_.end(); ++it)
       it->second->Release();
   }
 
   virtual int32 GetEntryCount() const {
     return static_cast<int32>(entries_.size());
@@ skipping 11 matching lines @@
       it->second->Release();
       entries_.erase(it);
       return false;
     }
 
     open_count_++;
 
     it->second->AddRef();
     *entry = it->second;
 
+    if (soft_failures_)
+      it->second->set_fail_requests();
+
     return true;
   }
 
   virtual bool CreateEntry(const std::string& key, disk_cache::Entry** entry) {
     if (fail_requests_)
       return false;
 
     EntryMap::iterator it = entries_.find(key);
     DCHECK(it == entries_.end());
 
     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();
+
     return true;
   }
 
   virtual bool DoomEntry(const std::string& key) {
     EntryMap::iterator it = entries_.find(key);
     if (it != entries_.end()) {
       it->second->Release();
       entries_.erase(it);
     }
     return true;
@@ skipping 24 matching lines @@
 
   // returns number of times a cache entry was successfully opened
   int open_count() const { return open_count_; }
 
   // returns number of times a cache entry was successfully created
   int create_count() const { return create_count_; }
 
   // Fail any subsequent CreateEntry and OpenEntry.
   void set_fail_requests() { fail_requests_ = true; }
 
+  // Return entries that fail some of their requests.
+  void set_soft_failures(bool value) { soft_failures_ = value; }
+
  private:
   typedef base::hash_map<std::string, MockDiskEntry*> EntryMap;
   EntryMap entries_;
   int open_count_;
   int create_count_;
   bool fail_requests_;
+  bool soft_failures_;
 };
 
 class MockHttpCache {
  public:
   MockHttpCache() : http_cache_(new MockNetworkLayer(), new MockDiskCache()) {
   }
 
   net::HttpCache* http_cache() { return &http_cache_; }
 
   MockNetworkLayer* network_layer() {
@@ skipping 247 matching lines @@
   cache.disk_cache()->set_fail_requests();
 
   // Read from the network, and don't use the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
+TEST(HttpCache, SimpleGETWithDiskFailures) {
+  MockHttpCache cache;
+
+  cache.disk_cache()->set_soft_failures(true);
+
+  // Read from the network, and fail to write to the cache.
+  RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
+
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+  EXPECT_EQ(0, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+
+  // This one should see an empty cache again.
+  RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
+
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+  EXPECT_EQ(0, cache.disk_cache()->open_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
+}
+
 TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit) {
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // force this transaction to read from the cache
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
 
@@ skipping 244 matching lines @@
   Context* c = context_list[0];
   ASSERT_EQ(net::ERR_IO_PENDING, c->result);
   c->result = c->callback.WaitForResult();
   ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
 
   // Now we have 2 active readers and two queued transactions.
 
   c = context_list[1];
   ASSERT_EQ(net::ERR_IO_PENDING, c->result);
   c->result = c->callback.WaitForResult();
-  ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
+  if (c->result == net::OK)
+    ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
 
   // At this point we have one reader, two pending transactions and a task on
   // the queue to move to the next transaction. Now we cancel the request that
   // is the current reader, and expect the queued task to be able to start the
   // next request.
 
   c = context_list[2];
   c->trans.reset();
 
   for (int i = 3; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
     if (c->result == net::ERR_IO_PENDING)
       c->result = c->callback.WaitForResult();
-    ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
+    if (c->result == net::OK)
+      ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
   }
 
   // We should not have had to re-open the disk entry.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   for (int i = 0; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
@@ skipping 1107 matching lines @@
 
   // force this transaction to write to the cache again
   MockTransaction transaction(kSimpleGET_Transaction);
 
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }