Disk cache: Simplyfy some of the test infrastructure.

net/disk_cache/disk_cache_perftest.cc

 // Copyright (c) 2011 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 <string>
 
 #include "base/basictypes.h"
-#include "base/file_path.h"
-#include "base/file_util.h"
 #include "base/perftimer.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/test/test_file_util.h"
 #include "base/timer.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/block_files.h"
+#include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/disk_cache.h"
+#include "net/disk_cache/disk_cache_test_base.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/hash.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::Time;
 
-typedef PlatformTest DiskCacheTest;
-
 namespace {
 
 struct TestEntry {
   std::string key;
   int data_len;
 };
 typedef std::vector<TestEntry> TestEntries;
 
 const int kMaxSize = 16 * 1024 - 1;
 
@@ skipping 105 matching lines @@
 
   PerfTimeLogger timer("Hash disk cache keys");
   for (int i = 0; i < 300000; i++) {
     std::string key = GenerateKey(true);
     disk_cache::Hash(key);
   }
   timer.Done();
 }
 
 TEST_F(DiskCacheTest, CacheBackendPerformance) {
-  MessageLoopForIO message_loop;
-
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
                   base::Thread::Options(MessageLoop::TYPE_IO, 0)));
 
-  ScopedTestCache test_cache;
+  ASSERT_TRUE(CleanupCacheDir());
   TestOldCompletionCallback cb;
   disk_cache::Backend* cache;
   int rv = disk_cache::CreateCacheBackend(
-               net::DISK_CACHE, test_cache.path(), 0, false,
+               net::DISK_CACHE, cache_path_, 0, false,
                cache_thread.message_loop_proxy(), NULL, &cache, &cb);
 
   ASSERT_EQ(net::OK, cb.GetResult(rv));
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
   TestEntries entries;
   int num_entries = 1000;
 
   EXPECT_TRUE(TimeWrite(num_entries, cache, &entries));
 
   MessageLoop::current()->RunAllPending();
   delete cache;
 
   ASSERT_TRUE(file_util::EvictFileFromSystemCache(
-              test_cache.path().AppendASCII("index")));
+              cache_path_.AppendASCII("index")));
   ASSERT_TRUE(file_util::EvictFileFromSystemCache(
-              test_cache.path().AppendASCII("data_0")));
+              cache_path_.AppendASCII("data_0")));
   ASSERT_TRUE(file_util::EvictFileFromSystemCache(
-              test_cache.path().AppendASCII("data_1")));
+              cache_path_.AppendASCII("data_1")));
   ASSERT_TRUE(file_util::EvictFileFromSystemCache(
-              test_cache.path().AppendASCII("data_2")));
+              cache_path_.AppendASCII("data_2")));
   ASSERT_TRUE(file_util::EvictFileFromSystemCache(
-              test_cache.path().AppendASCII("data_3")));
+              cache_path_.AppendASCII("data_3")));
 
-  rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, test_cache.path(), 0,
+  rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, cache_path_, 0,
                                       false, cache_thread.message_loop_proxy(),
                                       NULL, &cache, &cb);
   ASSERT_EQ(net::OK, cb.GetResult(rv));
 
   EXPECT_TRUE(TimeRead(num_entries, cache, entries, true));
 
   EXPECT_TRUE(TimeRead(num_entries, cache, entries, false));
 
   MessageLoop::current()->RunAllPending();
   delete cache;
 }
 
 // Creating and deleting "entries" on a block-file is something quite frequent
 // (after all, almost everything is stored on block files). The operation is
 // almost free when the file is empty, but can be expensive if the file gets
 // fragmented, or if we have multiple files. This test measures that scenario,
 // by using multiple, highly fragmented files.
 TEST_F(DiskCacheTest, BlockFilesPerformance) {
-  MessageLoopForIO message_loop;
+  ASSERT_TRUE(CleanupCacheDir());
 
-  ScopedTestCache test_cache;
-
-  disk_cache::BlockFiles files(test_cache.path());
+  disk_cache::BlockFiles files(cache_path_);
   ASSERT_TRUE(files.Init(true));
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
   const int kNumEntries = 60000;
   disk_cache::Addr* address = new disk_cache::Addr[kNumEntries];
 
   PerfTimeLogger timer1("Fill three block-files");
 
@@ skipping 13 matching lines @@
 
     files.DeleteBlock(address[entry], false);
     EXPECT_TRUE(files.CreateBlock(disk_cache::RANKINGS, BlockSize(),
                                   &address[entry]));
   }
 
   timer2.Done();
   MessageLoop::current()->RunAllPending();
   delete[] address;
 }