Convert BlockFiles to use FilePath instead of wstring.

net/disk_cache/block_files.cc

 // Copyright (c) 2006-2008 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/disk_cache/block_files.h"
 
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/file_lock.h"
 
 using base::Time;
 
 namespace {
 
-const wchar_t* kBlockName = L"data_";
+const char* kBlockName = "data_";
 
 // This array is used to perform a fast lookup of the nibble bit pattern to the
 // type of entry that can be stored there (number of consecutive blocks).
 const char s_types[16] = {4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};
 
 // Returns the type of block (number of consecutive blocks that can be stored)
 // for a given nibble of the bitmap.
 inline int GetMapBlockType(uint8 value) {
   value &= 0xf;
   return s_types[value];
@@ skipping 164 matching lines @@
   init_ = false;
   for (unsigned int i = 0; i < block_files_.size(); i++) {
     if (block_files_[i]) {
       block_files_[i]->Release();
       block_files_[i] = NULL;
     }
   }
   block_files_.clear();
 }
 
-std::wstring BlockFiles::Name(int index) {
+FilePath BlockFiles::Name(int index) {
   // The file format allows for 256 files.
   DCHECK(index < 256 || index >= 0);
-  std::wstring name(path_);
-  std::wstring tmp = StringPrintf(L"%ls%d", kBlockName, index);
-  file_util::AppendToPath(&name, tmp);
-
-  return name;
+  std::string tmp = StringPrintf("%s%d", kBlockName, index);
+  return path_.AppendASCII(tmp);
 }
 
 bool BlockFiles::CreateBlockFile(int index, FileType file_type, bool force) {
-  std::wstring name = Name(index);
+  FilePath name = Name(index);
   int flags =
       force ? base::PLATFORM_FILE_CREATE_ALWAYS : base::PLATFORM_FILE_CREATE;
   flags |= base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_EXCLUSIVE_WRITE;
 
   scoped_refptr<File> file(new File(
-      base::CreatePlatformFile(name.c_str(), flags, NULL)));
+      base::CreatePlatformFile(name, flags, NULL)));
   if (!file->IsValid())
     return false;
 
   BlockFileHeader header;
   header.entry_size = Addr::BlockSizeForFileType(file_type);
   header.this_file = static_cast<int16>(index);
   DCHECK(index <= kint16max && index >= 0);
 
   return file->Write(&header, sizeof(header), 0);
 }
 
 bool BlockFiles::OpenBlockFile(int index) {
   if (block_files_.size() - 1 < static_cast<unsigned int>(index)) {
     DCHECK(index > 0);
     int to_add = index - static_cast<int>(block_files_.size()) + 1;
     block_files_.resize(block_files_.size() + to_add);
   }
 
-  std::wstring name = Name(index);
+  FilePath name = Name(index);
   scoped_refptr<MappedFile> file(new MappedFile());
 
-  if (!file->Init(name, kBlockHeaderSize)) {
-    LOG(ERROR) << "Failed to open " << name;
+  if (!file->Init(name.ToWStringHack(), kBlockHeaderSize)) {
+    LOG(ERROR) << "Failed to open " << name.value();
     return false;
   }
 
   if (file->GetLength() < static_cast<size_t>(kBlockHeaderSize)) {
-    LOG(ERROR) << "File too small " << name;
+    LOG(ERROR) << "File too small " << name.value();
     return false;
   }
 
   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
   if (kBlockMagic != header->magic || kCurrentVersion != header->version) {
     LOG(ERROR) << "Invalid file version or magic";
     return false;
   }
 
   if (header->updating) {
@@ skipping 124 matching lines @@
         reinterpret_cast<BlockFileHeader*>(next_file->buffer());
     if (!next_header->num_entries) {
       DCHECK_EQ(next_header->entry_size, header->entry_size);
       // Delete next_file and remove it from the chain.
       int file_index = header->next_file;
       header->next_file = next_header->next_file;
       DCHECK(block_files_.size() >= static_cast<unsigned int>(file_index));
       block_files_[file_index]->Release();
       block_files_[file_index] = NULL;
 
-      std::wstring name = Name(file_index);
+      FilePath name = Name(file_index);
       int failure = DeleteCacheFile(name) ? 0 : 1;
       UMA_HISTOGRAM_COUNTS("DiskCache.DeleteFailed2", failure);
       if (failure)
-        LOG(ERROR) << "Failed to delete " << name << " from the cache.";
+        LOG(ERROR) << "Failed to delete " << name.value() << " from the cache.";
       continue;
     }
 
     header = next_header;
     file = next_file;
   }
 }
 
 bool BlockFiles::CreateBlock(FileType block_type, int block_count,
                              Addr* block_address) {
@@ skipping 74 matching lines @@
     int num_entries = (file_size - sizeof(*header)) / header->entry_size;
     header->max_entries = num_entries;
   }
 
   FixAllocationCounters(header);
   header->updating = 0;
   return true;
 }
 
 }  // namespace disk_cache