Make sure that net_perftest doesn't leave temporary files.

net/disk_cache/disk_cache_perftest.cc

 // Copyright (c) 2006-2008 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"
@@ skipping 139 matching lines @@
   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;
 
-  std::wstring path_wstring = GetCachePath();
-  ASSERT_TRUE(DeleteCache(path_wstring.c_str()));
-  disk_cache::Backend* cache = disk_cache::CreateCacheBackend(path_wstring,
-                                                              false, 0);
+  ScopedTestCache test_cache;
+  disk_cache::Backend* cache =
+      disk_cache::CreateCacheBackend(test_cache.path_wstring(), false, 0);
   ASSERT_TRUE(NULL != cache);
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
   TestEntries entries;
   int num_entries = 1000;
 
   int ret = TimeWrite(num_entries, cache, &entries);
   EXPECT_EQ(ret, g_cache_tests_received);
 
   MessageLoop::current()->RunAllPending();
   delete cache;
 
-  FilePath path = FilePath::FromWStringHack(path_wstring);
+  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
+              test_cache.path().AppendASCII("index")));
+  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
+              test_cache.path().AppendASCII("data_0")));
+  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
+              test_cache.path().AppendASCII("data_1")));
+  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
+              test_cache.path().AppendASCII("data_2")));
+  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
+              test_cache.path().AppendASCII("data_3")));
 
-  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
-              path.AppendASCII("index")));
-  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
-              path.AppendASCII("data_0")));
-  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
-              path.AppendASCII("data_1")));
-  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
-              path.AppendASCII("data_2")));
-  ASSERT_TRUE(file_util::EvictFileFromSystemCache(
-              path.AppendASCII("data_3")));
-
-  cache = disk_cache::CreateCacheBackend(path_wstring, false, 0);
+  cache = disk_cache::CreateCacheBackend(test_cache.path_wstring(), false, 0);
   ASSERT_TRUE(NULL != cache);
 
   ret = TimeRead(num_entries, cache, entries, true);
   EXPECT_EQ(ret, g_cache_tests_received);
 
   ret = TimeRead(num_entries, cache, entries, false);
   EXPECT_EQ(ret, g_cache_tests_received);
 
   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;
-  std::wstring path = GetCachePath();
-  ASSERT_TRUE(DeleteCache(path.c_str()));
 
-  disk_cache::BlockFiles files(path);
+  ScopedTestCache test_cache;
+
+  disk_cache::BlockFiles files(test_cache.path_wstring());
   ASSERT_TRUE(files.Init(true));
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
   const int kNumEntries = 60000;
   int32 buffer[kNumEntries];
   memset(buffer, 0, sizeof(buffer));
   disk_cache::Addr* address = reinterpret_cast<disk_cache::Addr*>(buffer);
   ASSERT_EQ(sizeof(*address), sizeof(*buffer));
@@ skipping 15 matching lines @@
       entry = 0;
 
     files.DeleteBlock(address[entry], false);
     EXPECT_TRUE(files.CreateBlock(disk_cache::RANKINGS, BlockSize(),
                                   &address[entry]));
   }
 
   timer2.Done();
   MessageLoop::current()->RunAllPending();
 }