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

net/tools/dump_cache/cache_dumper.cc

 // Copyright (c) 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.
 
 #include "net/tools/dump_cache/cache_dumper.h"
 
 #include "net/base/io_buffer.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"
 
 bool CacheDumper::CreateEntry(const std::string& key,
                               disk_cache::Entry** entry) {
   return cache_->CreateEntry(key, entry);
 }
 
-bool CacheDumper::WriteEntry(disk_cache::Entry* entry, int index, int offset,
-                             net::IOBuffer* buf, int buf_len) {
-  int written = entry->WriteData(index, offset, buf, buf_len, NULL, false);
-  return written == buf_len;
+int CacheDumper::WriteEntry(disk_cache::Entry* entry, int index, int offset,
+                            net::IOBuffer* buf, int buf_len,
+                            net::CompletionCallback* callback) {
+  return entry->WriteData(index, offset, buf, buf_len, callback, false);
 }
 
 void CacheDumper::CloseEntry(disk_cache::Entry* entry, base::Time last_used,
                              base::Time last_modified) {
   if (entry) {
     static_cast<disk_cache::EntryImpl*>(entry)->SetTimes(last_used,
                                                          last_modified);
     entry->Close();
   }
 }
 
 // A version of CreateDirectory which supports lengthy filenames.
 // Returns true on success, false on failure.
 bool SafeCreateDirectory(const std::wstring& path) {
 #ifdef WIN32_LARGE_FILENAME_SUPPORT
   // Due to large paths on windows, it can't simply do a
   // CreateDirectory("a/b/c").  Instead, create each subdirectory manually.
   bool rv = false;
   std::wstring::size_type pos(0);
   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.find(header) == 0)
     pos = 4;
 
   // Create the subdirectories individually
-  while((pos = path.find(backslash, pos)) != std::wstring::npos) {
+  while ((pos = path.find(backslash, pos)) != std::wstring::npos) {
     std::wstring subdir = path.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.c_str(), NULL) == TRUE;
 #else
   return file_util::CreateDirectory(path);
 #endif
@@ skipping 72 matching lines @@
     output->append(name);
     output->append(": ");
     output->append(value);
     output->append("\r\n");
   }
 
   // Mark the end of headers
   output->append("\r\n");
 }
 
-bool DiskDumper::WriteEntry(disk_cache::Entry* entry, int index, int offset,
-                            net::IOBuffer* buf, int buf_len) {
+int DiskDumper::WriteEntry(disk_cache::Entry* entry, int index, int offset,
+                           net::IOBuffer* buf, int buf_len,
+                           net::CompletionCallback* callback) {
   if (!entry_)
-    return false;
+    return 0;
 
   std::string headers;
   const char *data;
   size_t len;
   if (index == 0) {  // Stream 0 is the headers.
     net::HttpResponseInfo response_info;
     bool truncated;
     if (!net::HttpCache::ParseResponseInfo(buf->data(), buf_len,
                                            &response_info, &truncated))
-      return false;
+      return 0;
 
     // Skip this entry if it was truncated (results in an empty file).
     if (truncated)
-      return true;
+      return buf_len;
 
     // Remove the size headers.
     response_info.headers->RemoveHeader("transfer-encoding");
     response_info.headers->RemoveHeader("content-length");
     response_info.headers->RemoveHeader("x-original-url");
 
     // Convert the headers into a string ending with LF.
     GetNormalizedHeaders(response_info, &headers);
 
     // Append a header for the original URL.
     std::string url = entry_url_;
     // strip off the "XXGET" which may be in the key.
     std::string::size_type pos(0);
     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.
     data = buf->data();
     len = buf_len;
   }
 #ifdef WIN32_LARGE_FILENAME_SUPPORT
   DWORD bytes;
-  DWORD rv = WriteFile(entry_, data, len, &bytes, 0);
-  return rv == TRUE && bytes == static_cast<DWORD>(len);
+  if (!WriteFile(entry_, data, len, &bytes, 0))
+    return 0;
+
+  return bytes;
 #else
-  int bytes = fwrite(data, 1, len, entry_);
-  return bytes == len;
+  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
 }