Run the disk cache tests in scoped temporary directories instead of a fixed directory so that they …

net/disk_cache/stress_cache.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.
 
 // This is a simple application that stress-tests the crash recovery of the disk
 // cache. The main application starts a copy of itself on a loop, checking the
 // exit code of the child process. When the child dies in an unexpected way,
 // the main application quits.
 
 // The child application has two threads: one to exercise the cache in an
 // infinite loop, and another one to asynchronously kill the process.
 
 // A regular build should never crash.
 // To test that the disk cache doesn't generate critical errors with regular
 // application level crashes, edit stress_support.h.
 
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/debugger.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
+#include "base/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/stress_support.h"
 #include "net/disk_cache/trace.h"
 
 #if defined(OS_WIN)
 #include "base/logging_win.h"
 #endif
 
 using base::Time;
 
 const int kError = -1;
 const int kExpectedCrash = 100;
+const char kIterationSwitch[] = "iteration";
+const char kCachePathSwitch[] = "cache_path";
 
 // Starts a new process.
-int RunSlave(int iteration) {
+int RunSlave(int iteration, const FilePath& path) {
   FilePath exe;
   PathService::Get(base::FILE_EXE, &exe);
 
   CommandLine cmdline(exe);
-  cmdline.AppendArg(base::IntToString(iteration));
+  cmdline.AppendSwitchASCII(kIterationSwitch, base::IntToString(iteration));
+  cmdline.AppendSwitchPath(kCachePathSwitch, path);
 
   base::ProcessHandle handle;
   if (!base::LaunchProcess(cmdline, base::LaunchOptions(), &handle)) {
     printf("Unable to run test\n");
     return kError;
   }
 
   int exit_code;
   if (!base::WaitForExitCode(handle, &exit_code)) {
     printf("Unable to get return code\n");
     return kError;
   }
   return exit_code;
 }
 
 // Main loop for the master process.
 int MasterCode() {
+  ScopedTempDir path;

[rvargas (doing something else), 2012/08/16 22:26:43]

Sorry, what I meant is that stress tests as a whole should run with a fixed
folder.

This is not something that runs on any bot and there is no advantage to use a
scoped folder. On the other hand, running the executable again (and expecting it
to continue where it was interrupted) is a very common use case, as is the case
of going to the well known destination folder and inspect or run other tools on
that folder.

The simplest thing is to leave this file alone.

+  CHECK(path.CreateUniqueTempDir());
   for (int i = 0; i < 100000; i++) {
-    int ret = RunSlave(i);
+    int ret = RunSlave(i, path.path());
     if (kExpectedCrash != ret)
       return ret;
   }
 
   printf("More than enough...\n");
 
   return 0;
 }
 
 // -----------------------------------------------------------------------
 
 std::string GenerateStressKey() {
   char key[20 * 1024];
   size_t size = 50 + rand() % 20000;
   CacheTestFillBuffer(key, size, true);
 
   key[size - 1] = '\0';
   return std::string(key);
 }
 
 // This thread will loop forever, adding and removing entries from the cache.
 // iteration is the current crash cycle, so the entries on the cache are marked
 // to know which instance of the application wrote them.
 void StressTheCache(int iteration) {
+  FilePath path = CommandLine::ForCurrentProcess()->GetSwitchValuePath(
+      kCachePathSwitch);
+
   int cache_size = 0x2000000;  // 32MB.
   uint32 mask = 0xfff;  // 4096 entries.
-  FilePath path = GetCacheFilePath().InsertBeforeExtensionASCII("_stress");
 
   base::Thread cache_thread("CacheThread");
   if (!cache_thread.StartWithOptions(
           base::Thread::Options(MessageLoop::TYPE_IO, 0)))
     return;
 
   disk_cache::BackendImpl* cache =
       new disk_cache::BackendImpl(path, mask, cache_thread.message_loop_proxy(),
                                   NULL);
   cache->SetMaxSize(cache_size);
@@ skipping 139 matching lines @@
 int main(int argc, const char* argv[]) {
   // Setup an AtExitManager so Singleton objects will be destructed.
   base::AtExitManager at_exit_manager;
 
   if (argc < 2)
     return MasterCode();
 
   logging::SetLogAssertHandler(CrashHandler);
   logging::SetLogMessageHandler(MessageHandler);
 
+  CommandLine::Init(argc, argv);
 #if defined(OS_WIN)
   logging::LogEventProvider::Initialize(kStressCacheTraceProviderName);
 #else
-  CommandLine::Init(argc, argv);
   logging::InitLogging(NULL, logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
                        logging::LOCK_LOG_FILE, logging::DELETE_OLD_LOG_FILE,
                        logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
 #endif
 
   // Some time for the memory manager to flush stuff.
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(3));
   MessageLoop message_loop(MessageLoop::TYPE_IO);
 
-  char* end;
-  long int iteration = strtol(argv[1], &end, 0);
+
+  int iteration;
+  base::StringToInt(
+      CommandLine::ForCurrentProcess()->GetSwitchValueASCII(kIterationSwitch),
+      &iteration);
 
   if (!StartCrashThread()) {
     printf("failed to start thread\n");
     return kError;
   }
 
   StressTheCache(iteration);
   return 0;
 }