Adding a simple class for dumping the contents of a cache. Use this new class in dump_cache.

net/tools/dump_cache/dump_files.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.
 
 // Performs basic inspection of the disk cache files with minimal disruption
 // to the actual files (they still may change if an error is detected on the
 // files).
 
+#include "net/tools/dump_cache/dump_files.h"
+
 #include <stdio.h>
 
 #include <set>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "net/base/file_stream.h"
 #include "net/disk_cache/block_files.h"
 #include "net/disk_cache/disk_format.h"
 #include "net/disk_cache/mapped_file.h"
 #include "net/disk_cache/storage_block.h"
 #include "net/disk_cache/storage_block-inl.h"
 
 namespace {
 
-const wchar_t kIndexName[] = L"index";
+const FilePath::CharType kIndexName[] = FILE_PATH_LITERAL("index");
 
 // Reads the |header_size| bytes from the beginning of file |name|.
 bool ReadHeader(const FilePath& name, char* header, int header_size) {
   net::FileStream file(NULL);
   file.OpenSync(name, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ);
   if (!file.IsOpen()) {
-    printf("Unable to open file %ls\n", name.value().c_str());
+    printf("Unable to open file %s\n", name.MaybeAsASCII().c_str());
     return false;
   }
 
   int read = file.ReadSync(header, header_size);
   if (read != header_size) {
-    printf("Unable to read file %ls\n", name.value().c_str());
+    printf("Unable to read file %s\n", name.MaybeAsASCII().c_str());
     return false;
   }
   return true;
 }
 
 int GetMajorVersionFromFile(const FilePath& name) {
   disk_cache::IndexHeader header;
   if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header)))
     return 0;
 
@@ skipping 26 matching lines @@
   printf("operation list: %d\n", header.lru.operation_list);
   printf("-------------------------\n\n");
 }
 
 // Dumps the contents of a block-file header.
 void DumpBlockHeader(const FilePath& name) {
   disk_cache::BlockFileHeader header;
   if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header)))
     return;
 
-  printf("Block file: %ls\n", name.BaseName().value().c_str());
+  printf("Block file: %s\n", name.BaseName().MaybeAsASCII().c_str());
   printf("magic: %x\n", header.magic);
   printf("version: %d.%d\n", header.version >> 16, header.version & 0xffff);
   printf("file id: %d\n", header.this_file);
   printf("next file id: %d\n", header.next_file);
   printf("entry size: %d\n", header.entry_size);
   printf("current entries: %d\n", header.num_entries);
   printf("max entries: %d\n", header.max_entries);
   printf("updating: %d\n", header.updating);
   printf("empty sz 1: %d\n", header.empty[0]);
   printf("empty sz 2: %d\n", header.empty[1]);
@@ skipping 165 matching lines @@
 
 // -----------------------------------------------------------------------
 
 int GetMajorVersion(const FilePath& input_path) {
   FilePath index_name(input_path.Append(kIndexName));
 
   int version = GetMajorVersionFromFile(index_name);
   if (!version)
     return 0;
 
-  FilePath data_name(input_path.Append(L"data_0"));
+  FilePath data_name(input_path.Append(FILE_PATH_LITERAL("data_0")));
   if (version != GetMajorVersionFromFile(data_name))
     return 0;
 
-  data_name = input_path.Append(L"data_1");
+  data_name = input_path.Append(FILE_PATH_LITERAL("data_1"));
   if (version != GetMajorVersionFromFile(data_name))
     return 0;
 
+  data_name = input_path.Append(FILE_PATH_LITERAL("data_2"));
+  if (version != GetMajorVersionFromFile(data_name))
+    return 0;
+
+  data_name = input_path.Append(FILE_PATH_LITERAL("data_3"));
+  if (version != GetMajorVersionFromFile(data_name))
+    return 0;
+
   return version;
 }
 
 // Dumps the headers of all files.
 int DumpHeaders(const FilePath& input_path) {
   FilePath index_name(input_path.Append(kIndexName));
   DumpIndexHeader(index_name);
 
   file_util::FileEnumerator iter(input_path, false,
-                                 file_util::FileEnumerator::FILES, L"data_*");
+                                 file_util::FileEnumerator::FILES,
+                                 FILE_PATH_LITERAL("data_*"));
   for (FilePath file = iter.Next(); !file.empty(); file = iter.Next())
     DumpBlockHeader(file);
   return 0;
 }
 
 // Dumps all entries from the cache.
 int DumpContents(const FilePath& input_path) {
   DumpHeaders(input_path);
 
   // We need a message loop, although we really don't run any task.
   MessageLoop loop(MessageLoop::TYPE_IO);
   CacheDumper dumper(input_path);
   if (!dumper.Init())
     return -1;
 
   disk_cache::EntryStore entry;
   while (dumper.GetEntry(&entry)) {
     DumpEntry(entry);
     disk_cache::RankingsNode rankings;
     if (dumper.LoadRankings(entry.rankings_node, &rankings))
       DumpRankings(rankings);
   }
 
   printf("Done.\n");
 
   return 0;
 }