Implement some missing file util functions.

base/file_util_posix.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 "base/file_util.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <fnmatch.h>
 #include <fts.h>
@@ skipping 304 matching lines @@
 bool GetFileInfo(const FilePath& file_path, FileInfo* results) {
   struct stat64 file_info;
   if (stat64(file_path.value().c_str(), &file_info) != 0)
     return false;
   results->is_directory = S_ISDIR(file_info.st_mode);
   results->size = file_info.st_size;
   return true;
 }
 
 FILE* OpenFile(const std::string& filename, const char* mode) {
-  return fopen(filename.c_str(), mode);
+  return OpenFile(FilePath(filename), mode);
 }
 
-FILE* OpenFile(const std::wstring& filename, const char* mode) {
-  return fopen(WideToUTF8(filename).c_str(), mode);
+FILE* OpenFile(const FilePath& filename, const char* mode) {
+  return fopen(filename.value().c_str(), mode);
 }
 
 int ReadFile(const std::wstring& filename, char* data, int size) {
   int fd = open(WideToUTF8(filename).c_str(), O_RDONLY);
   if (fd < 0)
     return -1;
-  
+
   int ret_value = read(fd, data, size);
   close(fd);
   return ret_value;
 }
 
 int WriteFile(const std::wstring& filename, const char* data, int size) {
   int fd = creat(WideToUTF8(filename).c_str(), 0666);
   if (fd < 0)
     return -1;
 
   // Allow for partial writes
   ssize_t bytes_written_total = 0;
   do {
     ssize_t bytes_written_partial = write(fd,
                                           data + bytes_written_total,
                                           size - bytes_written_total);
     if (bytes_written_partial < 0) {
       close(fd);
-      return -1;      
+      return -1;
     }
     bytes_written_total += bytes_written_partial;
   } while (bytes_written_total < size);
 
   close(fd);
   return bytes_written_total;
 }
 
 // Gets the current working directory for the process.
 bool GetCurrentDirectory(FilePath* dir) {
   char system_buffer[PATH_MAX] = "";
   if (!getcwd(system_buffer, sizeof(system_buffer))) {
     NOTREACHED();
     return false;
   }
   *dir = FilePath(system_buffer);
   return true;
 }
 
 // Sets the current working directory for the process.
-bool SetCurrentDirectory(const std::wstring& current_directory) {
-  int ret = chdir(WideToUTF8(current_directory).c_str());
-  return (ret == 0);
+bool SetCurrentDirectory(const FilePath& path) {
+  int ret = chdir(path.value().c_str());
+  return !ret;
 }
-  
+
 FileEnumerator::FileEnumerator(const std::wstring& root_path,
                                bool recursive,
                                FileEnumerator::FILE_TYPE file_type)
     : recursive_(recursive),
       file_type_(file_type),
       is_in_find_op_(false),
       fts_(NULL) {
   pending_paths_.push(root_path);
 }
 
 FileEnumerator::FileEnumerator(const std::wstring& root_path,
                                bool recursive,
                                FileEnumerator::FILE_TYPE file_type,
                                const std::wstring& pattern)
     : recursive_(recursive),
       file_type_(file_type),
       pattern_(root_path),
       is_in_find_op_(false),
       fts_(NULL) {
   // The Windows version of this code only matches against items in the top-most
   // directory, and we're comparing fnmatch against full paths, so this is the
   // easiest way to get the right pattern.
   AppendToPath(&pattern_, pattern);
   pending_paths_.push(root_path);
 }
-  
+
 FileEnumerator::~FileEnumerator() {
   if (fts_)
     fts_close(fts_);
 }
 
 // As it stands, this method calls itself recursively when the next item of
 // the fts enumeration doesn't match (type, pattern, etc.).  In the case of
 // large directories with many files this can be quite deep.
 // TODO(erikkay) - get rid of this recursive pattern
 std::wstring FileEnumerator::Next() {
@@ skipping 47 matching lines @@
     return (file_type_ & FileEnumerator::DIRECTORIES) ? cur_file : Next();
   } else if (fts_ent->fts_info == FTS_F) {
     return (file_type_ & FileEnumerator::FILES) ? cur_file : Next();
   }
   // TODO(erikkay) - verify that the other fts_info types aren't interesting
   return Next();
 }
   
   
 } // namespace file_util