Disk Cache: Replace the worker pool with a sequenced worker pool (posix).

net/disk_cache/backend_unittest.cc

 // Copyright (c) 2012 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/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/port.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 43 matching lines @@
 
   disk_cache::Entry* entry = NULL;
   rv = cache->CreateEntry(kExistingEntryKey, &entry, cb.callback());
   if (cb.GetResult(rv) != net::OK)
     return scoped_ptr<disk_cache::BackendImpl>();
   entry->Close();
 
   return cache.Pass();
 }
 
+// Perform IO operations on the cache until there is pending IO.
+// This function requires the use of a single thread for the cache.

[gavinp, 2013/09/09 21:18:16]

I think grammar is confusing me a bit here. Does this mean "This function
requires that the cache is running on a single thread" ?

As well, could we be asserting on the mode the cache is running in?

[rvargas (doing something else), 2013/09/09 22:26:57]

Done.

+int GeneratePendingIO(disk_cache::Backend* cache,
+                      net::TestCompletionCallback* cb) {
+  disk_cache::EntryImpl* entry;
+  int rv = cache->CreateEntry("some key",
+                              reinterpret_cast<disk_cache::Entry**>(&entry),
+                              cb->callback());
+  if (cb->GetResult(rv) != net::OK)
+    return net::ERR_CACHE_CREATE_FAILURE;
+
+  const int kSize = 25000;
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
+  CacheTestFillBuffer(buffer->data(), kSize, false);
+
+  for (int i = 0; i < 10 * 1024 * 1024; i += 64 * 1024) {
+    // We are using the current thread as the cache thread because we want to
+    // be able to call directly this method to make sure that the OS (instead
+    // of us switching thread) is returning IO pending.
+    rv = entry->WriteDataImpl(0, i, buffer.get(), kSize, cb->callback(), false);
+    if (rv == net::ERR_IO_PENDING)
+      break;
+    if (rv != kSize)
+      rv = net::ERR_FAILED;
+  }
+
+  // Don't call Close() to avoid going through the queue or we'll deadlock
+  // waiting for the operation to finish.
+  entry->Release();
+  return rv;
+}
+
 }  // namespace
 
 // Tests that can run with different types of caches.
 class DiskCacheBackendTest : public DiskCacheTestWithCache {
  protected:
   void BackendBasics();
   void BackendKeying();
   void BackendShutdownWithPendingFileIO(bool fast);
   void BackendShutdownWithPendingIO(bool fast);
   void BackendShutdownWithPendingCreate(bool fast);
@@ skipping 263 matching lines @@
   entry->Close();
 
   // And verify that the first file is still there.
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   ASSERT_EQ(kSize, file_util::ReadFile(filename, buffer2->data(), kSize));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize));
 }
 
 // Tests that we deal with file-level pending operations at destruction time.
 void DiskCacheBackendTest::BackendShutdownWithPendingFileIO(bool fast) {
+  ASSERT_TRUE(CleanupCacheDir());
+  uint32 flags = disk_cache::kNoBuffering;
+  if (!fast)
+    flags |= disk_cache::kNoRandom;
+
+  UseCurrentThread();
+  CreateBackend(flags, NULL);
+
   net::TestCompletionCallback cb;
-  int rv;
+  int rv = GeneratePendingIO(cache_.get(), &cb);
 
-  {
-    ASSERT_TRUE(CleanupCacheDir());
-    base::Thread cache_thread("CacheThread");
-    ASSERT_TRUE(cache_thread.StartWithOptions(
-        base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
+  // The cache destructor will see one pending operation here.
+  cache_.reset();
 
-    uint32 flags = disk_cache::kNoBuffering;
-    if (!fast)
-      flags |= disk_cache::kNoRandom;
-
-    UseCurrentThread();
-    CreateBackend(flags, NULL);
-
-    disk_cache::EntryImpl* entry;
-    rv = cache_->CreateEntry(
-        "some key", reinterpret_cast<disk_cache::Entry**>(&entry),
-        cb.callback());
-    ASSERT_EQ(net::OK, cb.GetResult(rv));
-
-    const int kSize = 25000;
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
-    CacheTestFillBuffer(buffer->data(), kSize, false);
-
-    for (int i = 0; i < 10 * 1024 * 1024; i += 64 * 1024) {
-      // We are using the current thread as the cache thread because we want to
-      // be able to call directly this method to make sure that the OS (instead
-      // of us switching thread) is returning IO pending.
-      rv =
-          entry->WriteDataImpl(0, i, buffer.get(), kSize, cb.callback(), false);
-      if (rv == net::ERR_IO_PENDING)
-        break;
-      EXPECT_EQ(kSize, rv);
-    }
-
-    // Don't call Close() to avoid going through the queue or we'll deadlock
-    // waiting for the operation to finish.
-    entry->Release();
-
-    // The cache destructor will see one pending operation here.
-    cache_.reset();
-
-    if (rv == net::ERR_IO_PENDING) {
-      if (fast)
-        EXPECT_FALSE(cb.have_result());
-      else
-        EXPECT_TRUE(cb.have_result());
-    }
+  if (rv == net::ERR_IO_PENDING) {
+    if (fast)
+      EXPECT_FALSE(cb.have_result());
+    else
+      EXPECT_TRUE(cb.have_result());
   }
 
   base::MessageLoop::current()->RunUntilIdle();
 
-#if defined(OS_WIN)
   // Wait for the actual operation to complete, or we'll keep a file handle that
-  // may cause issues later. Note that on Posix systems even though this test
-  // uses a single thread, the actual IO is posted to a worker thread and the
-  // cache destructor breaks the link to reach cb when the operation completes.
+  // may cause issues later.
   rv = cb.GetResult(rv);
-#endif
 }
 
 TEST_F(DiskCacheBackendTest, ShutdownWithPendingFileIO) {
   BackendShutdownWithPendingFileIO(false);
 }
 
 // Here and below, tests that simulate crashes are not compiled in LeakSanitizer
 // builds because they contain a lot of intentional memory leaks.
 // The wrapper scripts used to run tests under Valgrind Memcheck and
 // Heapchecker will also disable these tests under those tools. See:
 // tools/valgrind/gtest_exclude/net_unittests.gtest-memcheck.txt
 // tools/heapcheck/net_unittests.gtest-heapcheck.txt
 #if !defined(LEAK_SANITIZER)
 // We'll be leaking from this test.
 TEST_F(DiskCacheBackendTest, ShutdownWithPendingFileIO_Fast) {
   // The integrity test sets kNoRandom so there's a version mismatch if we don't
   // force new eviction.
   SetNewEviction();
   BackendShutdownWithPendingFileIO(true);
 }
 #endif
 
+// Tests that one cache instance is not affected by another one going away.
+TEST_F(DiskCacheBackendTest, MultipleInstancesWithPendingFileIO) {
+  base::ScopedTempDir store;
+  ASSERT_TRUE(store.CreateUniqueTempDir());
+
+  net::TestCompletionCallback cb;
+  scoped_ptr<disk_cache::Backend> extra_cache;
+  int rv = disk_cache::CreateCacheBackend(
+               net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, store.path(), 0,
+               false, base::MessageLoopProxy::current().get(), NULL,
+               &extra_cache, cb.callback());
+  ASSERT_EQ(net::OK, cb.GetResult(rv));
+  ASSERT_TRUE(extra_cache.get() != NULL);
+
+  ASSERT_TRUE(CleanupCacheDir());
+  SetNewEviction();  // Match the expected behavior for integrity verification.
+  UseCurrentThread();
+
+  CreateBackend(disk_cache::kNoBuffering, NULL);
+  rv = GeneratePendingIO(cache_.get(), &cb);
+
+  // cache_ has a pending operation, and extra_cache will go away.
+  extra_cache.reset();
+
+  if (rv == net::ERR_IO_PENDING)
+    EXPECT_FALSE(cb.have_result());
+
+  base::MessageLoop::current()->RunUntilIdle();
+
+  // Wait for the actual operation to complete, or we'll keep a file handle that
+  // may cause issues later.
+  rv = cb.GetResult(rv);
+}
+
 // Tests that we deal with background-thread pending operations.
 void DiskCacheBackendTest::BackendShutdownWithPendingIO(bool fast) {
   net::TestCompletionCallback cb;
 
   {
     ASSERT_TRUE(CleanupCacheDir());
     base::Thread cache_thread("CacheThread");
     ASSERT_TRUE(cache_thread.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
@@ skipping 1345 matching lines @@
   ASSERT_TRUE(cache_thread.StartWithOptions(
                   base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
   scoped_ptr<disk_cache::BackendImpl> cache =
       CreateExistingEntryCache(cache_thread, cache_path_);
   ASSERT_TRUE(cache.get());
 
   net::TestCompletionCallback cb;
 
   const int kRestartCount = 5;
-  for (int i=0; i < kRestartCount; ++i) {
+  for (int i = 0; i < kRestartCount; ++i) {
     cache.reset(new disk_cache::BackendImpl(
         cache_path_, cache_thread.message_loop_proxy(), NULL));
     int rv = cache->Init(cb.callback());
     ASSERT_EQ(net::OK, cb.GetResult(rv));
     EXPECT_EQ(1, cache->GetEntryCount());
 
     disk_cache::Entry* entry = NULL;
     rv = cache->OpenEntry(kExistingEntryKey, &entry, cb.callback());
     EXPECT_EQ(net::OK, cb.GetResult(rv));
     EXPECT_TRUE(entry);
@@ skipping 1600 matching lines @@
   void* iter = NULL;
   size_t count = 0;
   ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
   cache_->EndEnumeration(&iter);
 
   EXPECT_EQ(key_pool.size(), count);
   EXPECT_TRUE(keys_to_match.empty());
 }
 
 #endif  // !defined(OS_WIN)