Use DiskCacheTestWithCache for DiskCachePerfTests.

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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
@@ skipping 11 matching lines @@
 #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 "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::Time;
 
 namespace {
 
-class DiskCachePerfTest : public DiskCacheTest {
+class DiskCachePerfTest : public DiskCacheTestWithCache {
  protected:
-  void CacheBackendPerformance(net::BackendType backend_type);
+  void CacheBackendPerformance();
 };
 
 struct TestEntry {
   std::string key;
   int data_len;
 };
 typedef std::vector<TestEntry> TestEntries;
 
 const int kMaxSize = 16 * 1024 - 1;
 
@@ skipping 112 matching lines @@
   srand(seed);
 
   base::PerfTimeLogger timer("Hash disk cache keys");
   for (int i = 0; i < 300000; i++) {
     std::string key = GenerateKey(true);
     base::Hash(key);
   }
   timer.Done();
 }
 
-void DiskCachePerfTest::CacheBackendPerformance(net::BackendType backend_type) {
+void DiskCachePerfTest::CacheBackendPerformance() {
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
-  ASSERT_TRUE(CleanupCacheDir());
-  net::TestCompletionCallback cb;
-  std::unique_ptr<disk_cache::Backend> cache;
-  int rv = disk_cache::CreateCacheBackend(
-      net::DISK_CACHE, backend_type, cache_path_, 0, false,
-      cache_thread.task_runner(), NULL, &cache, cb.callback());
-
-  ASSERT_EQ(net::OK, cb.GetResult(rv));
-
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
+  InitCache();
+
   TestEntries entries;
   int num_entries = 1000;
 
-  EXPECT_TRUE(TimeWrite(num_entries, cache.get(), &entries));
+  EXPECT_TRUE(TimeWrite(num_entries, cache_.get(), &entries));
 
   base::MessageLoop::current()->RunUntilIdle();
-  cache.reset();
+  cache_.reset();
 
   // Flush all files in the cache out of system memory.
   const base::FilePath::StringType file_pattern = FILE_PATH_LITERAL("*");
   base::FileEnumerator enumerator(cache_path_, true /* recursive */,
                                   base::FileEnumerator::FILES, file_pattern);
   for (base::FilePath file_path = enumerator.Next(); !file_path.empty();
        file_path = enumerator.Next()) {
     ASSERT_TRUE(base::EvictFileFromSystemCache(file_path));
   }
   // And, cache directories.
-  if (backend_type == net::CACHE_BACKEND_SIMPLE) {
+  if (simple_cache_mode_) {
     ASSERT_TRUE(
         base::EvictFileFromSystemCache(cache_path_.AppendASCII("index-dir")));
   }
   ASSERT_TRUE(base::EvictFileFromSystemCache(cache_path_));
 
-  rv = disk_cache::CreateCacheBackend(
-      net::DISK_CACHE, backend_type, cache_path_, 0, false,
-      cache_thread.task_runner(), NULL, &cache, cb.callback());
-  ASSERT_EQ(net::OK, cb.GetResult(rv));
+  DisableFirstCleanup();
+  InitCache();
 
-  EXPECT_TRUE(TimeRead(num_entries, cache.get(), entries, true));
-
-  EXPECT_TRUE(TimeRead(num_entries, cache.get(), entries, false));
-
+  EXPECT_TRUE(TimeRead(num_entries, cache_.get(), entries, true));
+  EXPECT_TRUE(TimeRead(num_entries, cache_.get(), entries, false));
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(DiskCachePerfTest, CacheBackendPerformance) {
-  CacheBackendPerformance(net::CACHE_BACKEND_BLOCKFILE);
+  CacheBackendPerformance();
 }
 
 TEST_F(DiskCachePerfTest, SimpleCacheBackendPerformance) {
-  CacheBackendPerformance(net::CACHE_BACKEND_SIMPLE);
+  SetSimpleCacheMode();
+  CacheBackendPerformance();
 }
 
 // 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(DiskCachePerfTest, BlockFilesPerformance) {
   ASSERT_TRUE(CleanupCacheDir());
 
@@ skipping 26 matching lines @@
     EXPECT_TRUE(
         files.CreateBlock(disk_cache::RANKINGS, BlockSize(), &address[entry]));
   }
 
   timer2.Done();
   base::MessageLoop::current()->RunUntilIdle();
   delete[] address;
 }
 
 }  // namespace