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

net/tools/dump_cache/cache_dumper.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.
 
 #include "net/tools/dump_cache/cache_dumper.h"
 
 #include "base/utf_string_conversions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/tools/dump_cache/url_to_filename_encoder.h"
 
+CacheDumper::CacheDumper(disk_cache::Backend* cache)
+    : cache_(cache) {
+}
+
 int CacheDumper::CreateEntry(const std::string& key,
                              disk_cache::Entry** entry,
                              const net::CompletionCallback& callback) {
   return cache_->CreateEntry(key, entry, callback);
 }
 
 int CacheDumper::WriteEntry(disk_cache::Entry* entry, int index, int offset,
                             net::IOBuffer* buf, int buf_len,
                             const net::CompletionCallback& callback) {
   return entry->WriteData(index, offset, buf, buf_len, callback, false);
@@ skipping 19 matching lines @@
   std::wstring backslash(L"\\");
 
   // If the path starts with the long file header, skip over that
   const std::wstring kLargeFilenamePrefix(L"\\\\?\\");
   std::wstring header(kLargeFilenamePrefix);
   if (path.value().find(header) == 0)
     pos = 4;
 
   // Create the subdirectories individually
   while ((pos = path.value().find(backslash, pos)) != std::wstring::npos) {
-    std::wstring subdir = path.value().substr(0, pos);
+    FilePath::StringType subdir = path.value().substr(0, pos);
     CreateDirectoryW(subdir.c_str(), NULL);
     // we keep going even if directory creation failed.
     pos++;
   }
   // Now create the full path
   return CreateDirectoryW(path.value().c_str(), NULL) == TRUE;
 #else
   return file_util::CreateDirectory(path);
 #endif
 }
 
+DiskDumper::DiskDumper(const FilePath& path)
+    : path_(path), entry_(NULL) {
+  file_util::CreateDirectory(path);
+}
+
 int DiskDumper::CreateEntry(const std::string& key,
                             disk_cache::Entry** entry,
                             const net::CompletionCallback& callback) {
   // The URL may not start with a valid protocol; search for it.
   int urlpos = key.find("http");
   std::string url = urlpos > 0 ? key.substr(urlpos) : key;
-  std::string base_path = WideToASCII(path_.value());
+  std::string base_path = path_.MaybeAsASCII();
   std::string new_path =
       net::UrlToFilenameEncoder::Encode(url, base_path, false);
-  entry_path_ = FilePath(ASCIIToWide(new_path));
+  entry_path_ = FilePath::FromUTF8Unsafe(new_path);
 
 #ifdef WIN32_LARGE_FILENAME_SUPPORT
   // In order for long filenames to work, we'll need to prepend
   // the windows magic token.
   const std::wstring kLongFilenamePrefix(L"\\\\?\\");
   // There is no way to prepend to a filename.  We simply *have*
   // to convert to a wstring to do this.
   std::wstring name = kLongFilenamePrefix;
   name.append(entry_path_.value());
   entry_path_ = FilePath(name);
 #endif
 
   entry_url_ = key;
 
   SafeCreateDirectory(entry_path_.DirName());
 
-  std::wstring file = entry_path_.value();
+  FilePath::StringType file = entry_path_.value();
 #ifdef WIN32_LARGE_FILENAME_SUPPORT
   entry_ = CreateFileW(file.c_str(), GENERIC_WRITE|GENERIC_READ, 0, 0,
                        CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
   if (entry_ == INVALID_HANDLE_VALUE)
     wprintf(L"CreateFileW (%s) failed: %d\n", file.c_str(), GetLastError());
   return (entry_ != INVALID_HANDLE_VALUE) ? net::OK : net::ERR_FAILED;
 #else
   entry_ = file_util::OpenFile(entry_path_, "w+");
   return (entry_ != NULL) ? net::OK : net::ERR_FAILED;
 #endif
@@ skipping 74 matching lines @@
     if ((pos = url.find("http")) != 0) {
       if (pos != std::string::npos)
         url = url.substr(pos);
     }
     std::string x_original_url = "X-Original-Url: " + url + "\r\n";
     // we know that the last two bytes are CRLF.
     headers.replace(headers.length() - 2, 0, x_original_url);
 
     data = headers.c_str();
     len = headers.size();
-  } else if (index == 1) {  // Stream 1 is the data.
+  } else if (index == 1) {
     data = buf->data();
     len = buf_len;
+  } else {
+    return 0;
   }
+
 #ifdef WIN32_LARGE_FILENAME_SUPPORT
   DWORD bytes;
   if (!WriteFile(entry_, data, len, &bytes, 0))
     return 0;
 
   return bytes;
 #else
   return fwrite(data, 1, len, entry_);
 #endif
 }
 
 void DiskDumper::CloseEntry(disk_cache::Entry* entry, base::Time last_used,
                           base::Time last_modified) {
 #ifdef WIN32_LARGE_FILENAME_SUPPORT
   CloseHandle(entry_);
 #else
   file_util::CloseFile(entry_);
 #endif
 }