Step 2 in porting disk cache to using FilePath.

net/disk_cache/file_win.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/file.h"
 
+#include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/singleton.h"
 #include "net/disk_cache/disk_cache.h"
 
 namespace {
 
 // Structure used for asynchronous operations.
 struct MyOverlapped {
   MyOverlapped(disk_cache::File* file, size_t offset,
                disk_cache::FileIOCallback* callback);
@@ skipping 53 matching lines @@
 
 }  // namespace
 
 namespace disk_cache {
 
 File::File(base::PlatformFile file)
     : init_(true), mixed_(true), platform_file_(INVALID_HANDLE_VALUE),
       sync_platform_file_(file) {
 }
 
-bool File::Init(const std::wstring& name) {
+bool File::Init(const FilePath& name) {
   DCHECK(!init_);
   if (init_)
     return false;
 
-  platform_file_ = CreateFile(name.c_str(), GENERIC_READ | GENERIC_WRITE,
+  platform_file_ = CreateFile(name.value().c_str(),
+                              GENERIC_READ | GENERIC_WRITE,
                               FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                               OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
 
   if (INVALID_HANDLE_VALUE == platform_file_)
     return false;
 
   MessageLoopForIO::current()->RegisterIOHandler(
       platform_file_, Singleton<CompletionHandler>::get());
 
   init_ = true;
-  sync_platform_file_  = CreateFile(name.c_str(), GENERIC_READ | GENERIC_WRITE,
+  sync_platform_file_  = CreateFile(name.value().c_str(),
+                                    GENERIC_READ | GENERIC_WRITE,
                                     FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                                     OPEN_EXISTING, 0, NULL);
 
   if (INVALID_HANDLE_VALUE == sync_platform_file_)
     return false;
 
   return true;
 }
 
 File::~File() {
@@ skipping 168 matching lines @@
 void File::WaitForPendingIO(int* num_pending_io) {
   while (*num_pending_io) {
     // Asynchronous IO operations may be in flight and the completion may end
     // up calling us back so let's wait for them.
     MessageLoopForIO::IOHandler* handler = Singleton<CompletionHandler>::get();
     MessageLoopForIO::current()->WaitForIOCompletion(100, handler);
   }
 }
 
 }  // namespace disk_cache