Disk cache: Update the remove/insert data files.

net/tools/crash_cache/crash_cache.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.
 
 // 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>
@@ skipping 114 matching lines @@
 }
 
 // Makes sure that any pending task is processed.
 void FlushQueue(disk_cache::Backend* cache) {
   TestOldCompletionCallback cb;
   int rv =
       reinterpret_cast<disk_cache::BackendImpl*>(cache)->FlushQueueForTest(&cb);
   cb.GetResult(rv);  // Ignore the result;
 }
 
+bool CreateCache(const FilePath& path, base::Thread* thread,
+                 disk_cache::Backend** cache, TestOldCompletionCallback* cb) {
+  int size = 1024 * 1024;
+  int rv = disk_cache::BackendImpl::CreateBackend(
+               path, false, size, net::DISK_CACHE, disk_cache::kNoRandom,
+               thread->message_loop_proxy(), NULL, cache, cb);
+
+  return (cb->GetResult(rv) == net::OK && !(*cache)->GetEntryCount());
+}

[gavinp, 2011/11/28 16:15:01]

I take it that crash_cache.cc had bitrotted because of the client/server changes
in the cache architecture?

[rvargas (doing something else), 2011/11/28 19:06:18]

Kind of. Without this change, it sometimes generates files that have an explicit
2.1 version number (so tests that require 2.0 fail), and the size of the index
can be 512k, depending on where the program runs.

+
 // Generates the files for an empty and one item cache.
 int SimpleInsert(const FilePath& path, RankCrashes action,
                  base::Thread* cache_thread) {
   TestOldCompletionCallback cb;
   disk_cache::Backend* cache;
-  int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, path, 0, false,
-                                          cache_thread->message_loop_proxy(),
-                                          NULL, &cache, &cb);
-  if (cb.GetResult(rv) != net::OK || cache->GetEntryCount())
+  if (!CreateCache(path, cache_thread, &cache, &cb))
     return GENERIC;
 
   const char* test_name = "some other key";
 
   if (action <= disk_cache::INSERT_EMPTY_3) {
     test_name = kCrashEntryName;
     disk_cache::g_rankings_crash = action;
   }
 
   disk_cache::Entry* entry;
-  rv = cache->CreateEntry(test_name, &entry, &cb);
+  int rv = cache->CreateEntry(test_name, &entry, &cb);
   if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   entry->Close();
   FlushQueue(cache);
 
   DCHECK(action <= disk_cache::INSERT_ONE_3);
   disk_cache::g_rankings_crash = action;
   test_name = kCrashEntryName;
 
   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,
                  base::Thread* cache_thread) {
   DCHECK(action >= disk_cache::REMOVE_ONE_1);
   DCHECK(action <= disk_cache::REMOVE_TAIL_3);
 
   TestOldCompletionCallback cb;
   disk_cache::Backend* cache;
-  // Use a simple LRU for eviction.
-  int rv = disk_cache::CreateCacheBackend(net::MEDIA_CACHE, path, 0, false,
-                                          cache_thread->message_loop_proxy(),
-                                          NULL, &cache, &cb);
-  if (cb.GetResult(rv) != net::OK || cache->GetEntryCount())
+  if (!CreateCache(path, cache_thread, &cache, &cb))
     return GENERIC;
 
   disk_cache::Entry* entry;
-  rv = cache->CreateEntry(kCrashEntryName, &entry, &cb);
+  int rv = cache->CreateEntry(kCrashEntryName, &entry, &cb);
   if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   entry->Close();
   FlushQueue(cache);
 
   if (action >= disk_cache::REMOVE_TAIL_1) {
     rv = cache->CreateEntry("some other key", &entry, &cb);
     if (cb.GetResult(rv) != net::OK)
       return GENERIC;
@@ skipping 14 matching lines @@
   return NOT_REACHED;
 }
 
 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);
 
   TestOldCompletionCallback cb;
   disk_cache::Backend* cache;
-  // Use a simple LRU for eviction.
-  int rv = disk_cache::CreateCacheBackend(net::MEDIA_CACHE, path, 0, false,
-                                          cache_thread->message_loop_proxy(),
-                                          NULL, &cache, &cb);
-  if (cb.GetResult(rv) != net::OK || cache->GetEntryCount())
+  if (!CreateCache(path, cache_thread, &cache, &cb))
     return GENERIC;
 
   disk_cache::Entry* entry;
-  rv = cache->CreateEntry("some other key", &entry, &cb);
+  int rv = cache->CreateEntry("some other key", &entry, &cb);
   if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   entry->Close();
   FlushQueue(cache);
   rv = cache->CreateEntry(kCrashEntryName, &entry, &cb);
   if (cb.GetResult(rv) != net::OK)
     return GENERIC;
 
   entry->Close();
@@ skipping 15 matching lines @@
 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, cache_thread->message_loop_proxy(), NULL);
   if (!cache || !cache->SetMaxSize(0x100000))
     return GENERIC;
 
+  // No experiments and use a simple LRU.
+  cache->SetFlags(disk_cache::kNoRandom);
   TestOldCompletionCallback cb;
   int rv = cache->Init(&cb);
   if (cb.GetResult(rv) != net::OK || cache->GetEntryCount())
     return GENERIC;
 
   int seed = static_cast<int>(Time::Now().ToInternalValue());
   srand(seed);
 
   disk_cache::Entry* entry;
   for (int i = 0; i < 100; i++) {
@@ skipping 87 matching lines @@
 
   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);
 }