First cut for a FreeBSD port - much still not working

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 <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <fnmatch.h>
@@ skipping 64 matching lines @@
   Lock lock_;
   friend struct DefaultSingletonTraits<LocaleAwareComparator>;
 
   DISALLOW_COPY_AND_ASSIGN(LocaleAwareComparator);
 };
 
 }  // namespace
 
 namespace file_util {
 
+#if defined(OS_FREEBSD)
+typedef struct stat stat_wrapper_t;
+static int CallStat(const char *path, stat_wrapper_t *sb) {
+  return stat(path, sb);
+}
+#else
+typedef struct stat64 stat_wrapper_t;
+static int CallStat(const char *path, stat_wrapper_t *sb) {
+  return stat64(path, sb);
+}
+#endif
+
+
 #if defined(GOOGLE_CHROME_BUILD)
 static const char* kTempFileName = "com.google.chrome.XXXXXX";
 #else
 static const char* kTempFileName = "org.chromium.XXXXXX";
 #endif
 
 std::wstring GetDirectoryFromPath(const std::wstring& path) {
   if (EndsWithSeparator(path)) {
     std::wstring dir = path;
     TrimTrailingSeparator(&dir);
@@ skipping 12 matching lines @@
   *path = FilePath(full_path);
   return true;
 }
 
 int CountFilesCreatedAfter(const FilePath& path,
                            const base::Time& comparison_time) {
   int file_count = 0;
 
   DIR* dir = opendir(path.value().c_str());
   if (dir) {
-#if !defined(OS_LINUX) && !defined(OS_MACOSX)
+#if !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_FREEBSD)
   #error Depending on the definition of struct dirent, additional space for \
       pathname may be needed
 #endif
     struct dirent ent_buf;
     struct dirent* ent;
     while (readdir_r(dir, &ent_buf, &ent) == 0 && ent) {
       if ((strcmp(ent->d_name, ".") == 0) ||
           (strcmp(ent->d_name, "..") == 0))
         continue;
 
-      struct stat64 st;
-      int test = stat64(path.Append(ent->d_name).value().c_str(), &st);
+      stat_wrapper_t st;
+      int test = CallStat(path.Append(ent->d_name).value().c_str(), &st);
       if (test != 0) {
         LOG(ERROR) << "stat64 failed: " << strerror(errno);
         continue;
       }
       // Here, we use Time::TimeT(), which discards microseconds. This
       // means that files which are newer than |comparison_time| may
       // be considered older. If we don't discard microseconds, it
       // introduces another issue. Suppose the following case:
       //
       // 1. Get |comparison_time| by Time::Now() and the value is 10.1 (secs).
@@ skipping 13 matching lines @@
   }
   return file_count;
 }
 
 // TODO(erikkay): The Windows version of this accepts paths like "foo/bar/*"
 // which works both with and without the recursive flag.  I'm not sure we need
 // that functionality. If not, remove from file_util_win.cc, otherwise add it
 // here.
 bool Delete(const FilePath& path, bool recursive) {
   const char* path_str = path.value().c_str();
-  struct stat64 file_info;
-  int test = stat64(path_str, &file_info);
+  stat_wrapper_t file_info;
+  int test = CallStat(path_str, &file_info);
   if (test != 0) {
     // The Windows version defines this condition as success.
     bool ret = (errno == ENOENT || errno == ENOTDIR);
     return ret;
   }
   if (!S_ISDIR(file_info.st_mode))
     return (unlink(path_str) == 0);
   if (!recursive)
     return (rmdir(path_str) == 0);
 
@@ skipping 120 matching lines @@
     }
 
     current = traversal.Next();
     traversal.GetFindInfo(&info);
   }
 
   return success;
 }
 
 bool PathExists(const FilePath& path) {
-  struct stat64 file_info;
-  return (stat64(path.value().c_str(), &file_info) == 0);
+  stat_wrapper_t file_info;
+  return CallStat(path.value().c_str(), &file_info) == 0;
 }
 
 bool PathIsWritable(const FilePath& path) {
   FilePath test_path(path);
-  struct stat64 file_info;
-  if (stat64(test_path.value().c_str(), &file_info) != 0) {
+  stat_wrapper_t file_info;
+  if (CallStat(test_path.value().c_str(), &file_info) != 0) {
     // If the path doesn't exist, test the parent dir.
     test_path = test_path.DirName();
     // If the parent dir doesn't exist, then return false (the path is not
     // directly writable).
-    if (stat64(test_path.value().c_str(), &file_info) != 0)
+    if (CallStat(test_path.value().c_str(), &file_info) != 0)
       return false;
   }
   if (S_IWOTH & file_info.st_mode)
     return true;
   if (getegid() == file_info.st_gid && (S_IWGRP & file_info.st_mode))
     return true;
   if (geteuid() == file_info.st_uid && (S_IWUSR & file_info.st_mode))
     return true;
   return false;
 }
 
 bool DirectoryExists(const FilePath& path) {
-  struct stat64 file_info;
-  if (stat64(path.value().c_str(), &file_info) == 0)
+  stat_wrapper_t file_info;
+  if (CallStat(path.value().c_str(), &file_info) == 0)
     return S_ISDIR(file_info.st_mode);
   return false;
 }
 
 // TODO(erikkay): implement
 #if 0
 bool GetFileCreationLocalTimeFromHandle(int fd,
                                         LPSYSTEMTIME creation_time) {
   if (!file_handle)
     return false;
@@ skipping 111 matching lines @@
        i != subpaths.rend(); ++i) {
     if (!DirectoryExists(*i)) {
       if (mkdir(i->value().c_str(), 0700) != 0)
         return false;
     }
   }
   return true;
 }
 
 bool GetFileInfo(const FilePath& file_path, FileInfo* results) {
-  struct stat64 file_info;
-  if (stat64(file_path.value().c_str(), &file_info) != 0)
+  stat_wrapper_t file_info;
+  if (CallStat(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;
   results->last_modified = base::Time::FromTimeT(file_info.st_mtime);
   return true;
 }
 
 bool GetInode(const FilePath& path, ino_t* inode) {
   struct stat buffer;
   int result = stat(path.value().c_str(), &buffer);
@@ skipping 155 matching lines @@
   return root_path_.Append(directory_entries_[current_directory_entry_
       ].filename);
 }
 
 bool FileEnumerator::ReadDirectory(std::vector<DirectoryEntryInfo>* entries,
                                    const FilePath& source, bool show_links) {
   DIR* dir = opendir(source.value().c_str());
   if (!dir)
     return false;
 
-#if !defined(OS_LINUX) && !defined(OS_MACOSX)
+#if !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_FREEBSD)
   #error Depending on the definition of struct dirent, additional space for \
       pathname may be needed
 #endif
   struct dirent dent_buf;
   struct dirent* dent;
   while (readdir_r(dir, &dent_buf, &dent) == 0 && dent) {
     DirectoryEntryInfo info;
     info.filename = FilePath(dent->d_name);
 
     FilePath full_name = source.Append(dent->d_name);
@@ skipping 73 matching lines @@
     munmap(data_, length_);
   if (file_ != -1)
     close(file_);
 
   data_ = NULL;
   length_ = 0;
   file_ = -1;
 }
 
 } // namespace file_util