Disk cache: Update the disk cache tools and tests to use...

net/tools/crash_cache/crash_cache.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2006-2010 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 command-line program generates the set of files needed for the crash-
 // cache unit tests (DiskCacheTest,CacheBackend_Recover*). This program only
 // works properly on debug mode, because the crash functionality is not compiled
 // on release builds of the cache.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
-
+#include "base/thread.h"
+#include "net/base/net_errors.h"
+#include "net/base/test_completion_callback.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/rankings.h"
 
 using base::Time;
 
 enum Errors {
   GENERIC = -1,
   ALL_GOOD = 0,
@@ skipping 79 matching lines @@
 
   *full_path = path.AppendASCII(folders[action]);
 
   if (file_util::PathExists(*full_path))
     return false;
 
   return file_util::CreateDirectory(*full_path);
 }
 
 // Generates the files for an empty and one item cache.
-int SimpleInsert(const FilePath& path, RankCrashes action) {
-  disk_cache::Backend* cache = disk_cache::CreateCacheBackend(path, false, 0,
-                                                              net::DISK_CACHE);
-  if (!cache || cache->GetEntryCount())
+int SimpleInsert(const FilePath& path, RankCrashes action,
+                 base::Thread* cache_thread) {
+  TestCompletionCallback cb;
+  disk_cache::Backend* cache;
+  int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, path, 0, false,
+                                          cache_thread->message_loop_proxy(),
+                                          &cache, &cb);
+  if (cb.GetResult(rv) != net::OK || cache->GetEntryCount())
     return GENERIC;
 
   const char* test_name = "some other key";
 
   if (action <= disk_cache::INSERT_EMPTY_3) {
     test_name = kCrashEntryName;
     g_rankings_crash = action;
   }
 
   disk_cache::Entry* entry;
-  if (!cache->CreateEntry(test_name, &entry))
+  rv = cache->CreateEntry(test_name, &entry, &cb);
+  if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   entry->Close();
 
   DCHECK(action <= disk_cache::INSERT_ONE_3);
   g_rankings_crash = action;
   test_name = kCrashEntryName;
 
-  if (!cache->CreateEntry(test_name, &entry))
+  rv = cache->CreateEntry(test_name, &entry, &cb);
+  if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   return NOT_REACHED;
 }
 
 // Generates the files for a one item cache, and removing the head.
-int SimpleRemove(const FilePath& path, RankCrashes action) {
+int SimpleRemove(const FilePath& path, RankCrashes action,
+                 base::Thread* cache_thread) {
   DCHECK(action >= disk_cache::REMOVE_ONE_1);
   DCHECK(action <= disk_cache::REMOVE_TAIL_3);
 
-  disk_cache::Backend* cache = disk_cache::CreateCacheBackend(path, false, 0,
-                                                              net::DISK_CACHE);
-  if (!cache || cache->GetEntryCount())
+  TestCompletionCallback cb;
+  disk_cache::Backend* cache;
+  int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, path, 0, false,
+                                          cache_thread->message_loop_proxy(),
+                                          &cache, &cb);
+  if (cb.GetResult(rv) != net::OK || cache->GetEntryCount())
     return GENERIC;
 
   disk_cache::Entry* entry;
-  if (!cache->CreateEntry(kCrashEntryName, &entry))
+  rv = cache->CreateEntry(kCrashEntryName, &entry, &cb);
+  if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   entry->Close();
 
   if (action >= disk_cache::REMOVE_TAIL_1) {
-    if (!cache->CreateEntry("some other key", &entry))
+    rv = cache->CreateEntry("some other key", &entry, &cb);
+    if (cb.GetResult(rv) != net::OK)
       return GENERIC;
 
     entry->Close();
   }
 
-  if (!cache->OpenEntry(kCrashEntryName, &entry))
+  rv = cache->OpenEntry(kCrashEntryName, &entry, &cb);
+  if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   g_rankings_crash = action;
   entry->Doom();
   entry->Close();
 
   return NOT_REACHED;
 }
 
-int HeadRemove(const FilePath& path, RankCrashes action) {
+int HeadRemove(const FilePath& path, RankCrashes action,
+               base::Thread* cache_thread) {
   DCHECK(action >= disk_cache::REMOVE_HEAD_1);
   DCHECK(action <= disk_cache::REMOVE_HEAD_4);
 
-  disk_cache::Backend* cache = disk_cache::CreateCacheBackend(path, false, 0,
-                                                              net::DISK_CACHE);
-  if (!cache || cache->GetEntryCount())
+  TestCompletionCallback cb;
+  disk_cache::Backend* cache;
+  int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, path, 0, false,
+                                          cache_thread->message_loop_proxy(),
+                                          &cache, &cb);
+  if (cb.GetResult(rv) != net::OK || cache->GetEntryCount())
     return GENERIC;
 
   disk_cache::Entry* entry;
-  if (!cache->CreateEntry("some other key", &entry))
+  rv = cache->CreateEntry("some other key", &entry, &cb);
+  if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   entry->Close();
-  if (!cache->CreateEntry(kCrashEntryName, &entry))
+  rv = cache->CreateEntry(kCrashEntryName, &entry, &cb);
+  if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   entry->Close();
 
-  if (!cache->OpenEntry(kCrashEntryName, &entry))
+  rv = cache->OpenEntry(kCrashEntryName, &entry, &cb);
+  if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   g_rankings_crash = action;
   entry->Doom();
   entry->Close();
 
   return NOT_REACHED;
 }
 
 // Generates the files for insertion and removals on heavy loaded caches.
-int LoadOperations(const FilePath& path, RankCrashes action) {
+int LoadOperations(const FilePath& path, RankCrashes action,
+                   base::Thread* cache_thread) {
   DCHECK(action >= disk_cache::INSERT_LOAD_1);
 
-  // Work with a tiny index table (16 entries)
-  disk_cache::BackendImpl* cache =
-      new disk_cache::BackendImpl(path, 0xf);
-  if (!cache || !cache->SetMaxSize(0x100000) || !cache->Init() ||
-      cache->GetEntryCount())
+  // Work with a tiny index table (16 entries).
+  disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
+      path, 0xf, cache_thread->message_loop_proxy());
+  if (!cache || !cache->SetMaxSize(0x100000))
+    return GENERIC;
+
+  if (!cache->Init() || cache->GetEntryCount())
     return GENERIC;
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
+  TestCompletionCallback cb;
+  int rv;
   disk_cache::Entry* entry;
   for (int i = 0; i < 100; i++) {
     std::string key = GenerateKey(true);
-    if (!cache->CreateEntry(key, &entry))
+    rv = cache->CreateEntry(key, &entry, &cb);
+    if (cb.GetResult(rv) != net::OK)
       return GENERIC;
     entry->Close();
     if (50 == i && action >= disk_cache::REMOVE_LOAD_1) {
-      if (!cache->CreateEntry(kCrashEntryName, &entry))
+      rv = cache->CreateEntry(kCrashEntryName, &entry, &cb);
+      if (cb.GetResult(rv) != net::OK)
         return GENERIC;
       entry->Close();
     }
   }
 
   if (action <= disk_cache::INSERT_LOAD_2) {
     g_rankings_crash = action;
 
-    if (!cache->CreateEntry(kCrashEntryName, &entry))
+    rv = cache->CreateEntry(kCrashEntryName, &entry, &cb);
+    if (cb.GetResult(rv) != net::OK)
       return GENERIC;
   }
 
-  if (!cache->OpenEntry(kCrashEntryName, &entry))
+  rv = cache->OpenEntry(kCrashEntryName, &entry, &cb);
+  if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   g_rankings_crash = action;
 
   entry->Doom();
   entry->Close();
 
   return NOT_REACHED;
 }
 
 // Main function on the child process.
 int SlaveCode(const FilePath& path, RankCrashes action) {
-  MessageLoop message_loop;
+  MessageLoopForIO message_loop;
 
   FilePath full_path;
   if (!CreateTargetFolder(path, action, &full_path)) {
     printf("Destination folder found, please remove it.\n");
     return CRASH_OVERWRITE;
   }
 
+  base::Thread cache_thread("CacheThread");
+  if (!cache_thread.StartWithOptions(
+          base::Thread::Options(MessageLoop::TYPE_IO, 0)))
+    return GENERIC;
+
   if (action <= disk_cache::INSERT_ONE_3)
-    return SimpleInsert(full_path, action);
+    return SimpleInsert(full_path, action, &cache_thread);
 
   if (action <= disk_cache::INSERT_LOAD_2)
-    return LoadOperations(full_path, action);
+    return LoadOperations(full_path, action, &cache_thread);
 
   if (action <= disk_cache::REMOVE_ONE_4)
-    return SimpleRemove(full_path, action);
+    return SimpleRemove(full_path, action, &cache_thread);
 
   if (action <= disk_cache::REMOVE_HEAD_4)
-    return HeadRemove(full_path, action);
+    return HeadRemove(full_path, action, &cache_thread);
 
   if (action <= disk_cache::REMOVE_TAIL_3)
-    return SimpleRemove(full_path, action);
+    return SimpleRemove(full_path, action, &cache_thread);
 
   if (action <= disk_cache::REMOVE_LOAD_3)
-    return LoadOperations(full_path, action);
+    return LoadOperations(full_path, action, &cache_thread);
 
   return NOT_REACHED;
 }
 
 // -----------------------------------------------------------------------
 
 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();
 
   char* end;
   RankCrashes action = static_cast<RankCrashes>(strtol(argv[1], &end, 0));
   if (action <= disk_cache::NO_CRASH || action >= disk_cache::MAX_CRASH) {
     printf("Invalid action\n");
     return INVALID_ARGUMENT;
   }
 
   FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
   path = path.AppendASCII("net");
   path = path.AppendASCII("data");
   path = path.AppendASCII("cache_tests");
   path = path.AppendASCII("new_crashes");
 
   return SlaveCode(path, action);
 }