Disk Cache: Replace the backend pointer of the ChildrenDeleter...

net/disk_cache/entry_unittest.cc

 // Copyright (c) 2006-2010 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 "base/basictypes.h"
 #include "base/platform_thread.h"
 #include "base/timer.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 1269 matching lines @@
   InitCache();
   DoomSparseEntry();
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomSparseEntry();
 }
 
+// A CompletionCallback that deletes the cache from within the callback. The way
+// a TestCompletionCallback works means that all tasks (even new ones) are
+// executed by the message loop before returning to the caller so the only way
+// to simulate a race is to execute what we want on the callback.
+class SparseTestCompletionCallback : public TestCompletionCallback {
+public:

[gavinp, 2010/07/27 15:29:44]

" public:"

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Class_...

+  explicit SparseTestCompletionCallback(disk_cache::Backend* cache)
+      : cache_(cache) {}
+
+  virtual void RunWithParams(const Tuple1<int>& params) {
+    delete cache_;
+    TestCompletionCallback::RunWithParams(params);
+  }
+private:

[gavinp, 2010/07/27 15:29:44]

" private:"

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Class_...

+  disk_cache::Backend* cache_;
+  DISALLOW_COPY_AND_ASSIGN(SparseTestCompletionCallback);
+};
+
+// Tests that we don't crash when the backend is deleted while we are working
+// deleting the sub-entries of a sparse entry.
+TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
+  SetDirectMode();
+  UseCurrentThread();
+  InitCache();
+  std::string key("the key");
+  disk_cache::Entry* entry;
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+
+  const int kSize = 4 * 1024;
+  scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+  CacheTestFillBuffer(buf->data(), kSize, false);
+
+  int64 offset = 1024;
+  // Write to a bunch of ranges.
+  for (int i = 0; i < 12; i++) {
+    EXPECT_EQ(kSize, entry->WriteSparseData(offset, buf, kSize, NULL));
+    offset *= 4;
+  }
+  EXPECT_EQ(9, cache_->GetEntryCount());
+
+  entry->Close();
+  SparseTestCompletionCallback cb(cache_);
+  int rv = cache_->DoomEntry(key, &cb);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(net::OK, cb.WaitForResult());
+
+  cache_ = NULL;

[gavinp, 2010/07/27 15:29:44]

What does this do?

[rvargas (doing something else), 2010/07/27 18:26:30]

We deleted the cache in the callback, but the test's TearDown doesn't know about
it and will attempt to destroy the object again. I added a comment.

+}
+
 void DiskCacheEntryTest::PartialSparseEntry() {
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   // We should be able to deal with IO that is not aligned to the block size
   // of a sparse entry, at least to write a big range without leaving holes.
   const int kSize = 4 * 1024;
   const int kSmallSize = 128;
   scoped_refptr<net::IOBuffer> buf1 = new net::IOBuffer(kSize);
@@ skipping 178 matching lines @@
   rv = cb1.WaitForResult();
   EXPECT_TRUE(rv == 4096 || rv == kSize);
   EXPECT_EQ(net::OK, cb2.WaitForResult());
   EXPECT_EQ(net::OK, cb3.WaitForResult());
   EXPECT_EQ(net::OK, cb4.WaitForResult());
 
   rv = entry->GetAvailableRange(offset, kSize, &offset, &cb5);
   EXPECT_EQ(0, cb5.GetResult(rv));
   entry->Close();
 }