Disk cache: Add a method to cancel pending sparse operations....

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 14 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), fail_requests_(false) {
+      : test_mode_(0), doomed_(false), sparse_(false), fail_requests_(false),
+        busy_(false), delayed_(false) {
   }
 
   explicit MockDiskEntry(const std::string& key)
-      : key_(key), doomed_(false), sparse_(false), fail_requests_(false) {
+      : key_(key), doomed_(false), sparse_(false), fail_requests_(false),
+        busy_(false), delayed_(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 74 matching lines @@
       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_)
+    if (!sparse_ || busy_)
       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);
+    busy_ = true;
+    delayed_ = false;
     return net::ERR_IO_PENDING;
   }
 
   virtual int WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
                               net::CompletionCallback* completion_callback) {
+    if (busy_)
+      return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
     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_)
+    if (!sparse_ || busy_)
       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);
@@ skipping 10 matching lines @@
         }
       } else {
         if (!data_[1][real_offset])
           break;
         count++;
       }
     }
     return count;
   }
 
+  virtual void CancelSparseIO() { cancel_ = true; }
+
+  virtual int ReadyForSparseIO(net::CompletionCallback* completion_callback) {
+    if (!cancel_)
+      return net::OK;
+
+    cancel_ = false;
+    DCHECK(completion_callback);
+    if (test_mode_ & TEST_MODE_SYNC_CACHE_READ)
+      return net::OK;
+
+    // The pending operation is already in the message loop (and hopefuly
+    // already in the second pass).  Just notify the caller that it finished.
+    CallbackLater(completion_callback, 0);
+    return net::ERR_IO_PENDING;
+  }
+
   // 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) {
+    if (busy_) {
+      // This is kind of hacky, but controlling the behavior of just this entry
+      // from a test is sort of complicated.  What we really want to do is
+      // delay the delivery of a sparse IO operation a little more so that the
+      // request start operation (async) will finish without seeing the end of
+      // this operation (already posted to the message loop)... and without
+      // just delaying for n mS (which may cause trouble with slow bots).  So
+      // we re-post this operation (all async sparse IO operations will take two
+      // trips trhough the message loop instead of one).
+      if (!delayed_) {
+        delayed_ = true;
+        return CallbackLater(callback, result);
+      }
+    }
+    busy_ = false;
     callback->Run(result);
   }
 
   std::string key_;
   std::vector<char> data_[2];
   int test_mode_;
   bool doomed_;
   bool sparse_;
   bool fail_requests_;
+  bool busy_;
+  bool delayed_;
+  static bool cancel_;
 };
 
+// Static.
+bool MockDiskEntry::cancel_ = false;
+
 class MockDiskCache : public disk_cache::Backend {
  public:
   MockDiskCache()
       : open_count_(0), create_count_(0), fail_requests_(false),
         soft_failures_(false) {
   }
 
   ~MockDiskCache() {
     EntryMap::iterator it = entries_.begin();
     for (; it != entries_.end(); ++it)
@@ skipping 2089 matching lines @@
   delete c;
 
   // Verify that the entry has not been deleted.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.disk_cache()->OpenEntry(kRangeGET_TransactionOK.url,
                                             &entry));
   entry->Close();
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
+// Tests that we don't delete a sparse entry when we start a new request after
+// cancelling the previous one.
+TEST(HttpCache, RangeGET_Cancel2) {
+  MockHttpCache cache;
+  cache.http_cache()->set_enable_range_support(true);
+  AddMockTransaction(&kRangeGET_TransactionOK);
+
+  RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
+  MockHttpRequest request(kRangeGET_TransactionOK);
+
+  Context* c = new Context();
+  int rv = cache.http_cache()->CreateTransaction(&c->trans);
+  EXPECT_EQ(net::OK, rv);
+
+  rv = c->trans->Start(&request, &c->callback, NULL);
+  if (rv == net::ERR_IO_PENDING)
+    rv = c->callback.WaitForResult();
+
+  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+
+  // Make sure that we revalidate the entry and read from the cache (a single
+  // read will return while waiting for the network).
+  scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(5);
+  rv = c->trans->Read(buf, buf->size(), &c->callback);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  rv = c->callback.WaitForResult();
+  rv = c->trans->Read(buf, buf->size(), &c->callback);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+
+  // Destroy the transaction before completing the read.
+  delete c;
+
+  // We have the read and the delete (OnProcessPendingQueue) waiting on the
+  // message loop. This means that a new transaction will just reuse the same
+  // active entry (no open or create).
+
+  RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
+
+  EXPECT_EQ(3, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+  RemoveMockTransaction(&kRangeGET_TransactionOK);
+}
+
 #ifdef NDEBUG
 // This test hits a NOTREACHED so it is a release mode only test.
 TEST(HttpCache, RangeGET_OK_LoadOnlyFromCache) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   // Write to the cache (40-49).
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
@@ skipping 560 matching lines @@
   std::string headers;
   response.headers->GetNormalizedHeaders(&headers);
 
   EXPECT_EQ("HTTP/1.1 200 OK\n"
             "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
             "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
             headers);
 
   RemoveMockTransaction(&mock_network_response);
 }