POSIX/Linux related changes to file_util....

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 <fcntl.h>
 #include <fnmatch.h>
 #include <fts.h>
 #include <libgen.h>
 #include <sys/errno.h>
 #include <sys/stat.h>
 #include <time.h>
 
 #include <fstream>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 
 namespace file_util {
 
+static const wchar_t* kTempFileName = L"com.google.chrome.XXXXXX";

[Dean McNamee, 2008/09/12 13:59:46]

Seems a waste to make this wide, just when we're going to convert it back down
again.

+
 std::wstring GetDirectoryFromPath(const std::wstring& path) {
   if (EndsWithSeparator(path)) {
     std::wstring dir = path;
     TrimTrailingSeparator(&dir);
     return dir;
   } else {
     char full_path[PATH_MAX];
     base::strlcpy(full_path, WideToUTF8(path).c_str(), arraysize(full_path));
     return UTF8ToWide(dirname(full_path));
   }
 }
   
 bool AbsolutePath(std::wstring* path) {
   char full_path[PATH_MAX];
   if (realpath(WideToUTF8(*path).c_str(), full_path) == NULL)
     return false;
   *path = UTF8ToWide(full_path);
   return true;
 }
 
 // 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 std::wstring& path, bool recursive) {
-  const char* utf8_path = WideToUTF8(path).c_str();
+  std::string utf8_path_string = WideToUTF8(path);
+  const char* utf8_path = utf8_path_string.c_str();
   struct stat64 file_info;
   int test = stat64(utf8_path, &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(utf8_path) == 0);
   if (!recursive)
@@ skipping 77 matching lines @@
                  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
                  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL));
   return GetFileCreationLocalTimeFromHandle(file_handle.Get(), creation_time);
 }
 #endif
 
 bool CreateTemporaryFileName(std::wstring* temp_file) {
   std::wstring tmpdir;
   if (!GetTempDir(&tmpdir))
     return false;
-  tmpdir.append(L"com.google.chrome.XXXXXX");
-  // this should be OK since mktemp just replaces characters in place
-  char* buffer = const_cast<char*>(WideToUTF8(tmpdir).c_str());
-  *temp_file = UTF8ToWide(mktemp(buffer));
-  int fd = open(buffer, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+  AppendToPath(&tmpdir, kTempFileName);
+  std::string tmpdir_string = WideToUTF8(tmpdir);
+  // this should be OK since mkstemp just replaces characters in place
+  char* buffer = const_cast<char*>(tmpdir_string.c_str());
+  int fd = mkstemp(buffer);
   if (fd < 0)
     return false;
-  close(fd);  
+  *temp_file = UTF8ToWide(buffer);
+  close(fd); 
   return true;
 }
 
 bool CreateNewTempDirectory(const std::wstring& prefix,
                             std::wstring* new_temp_path) {
   std::wstring tmpdir;
   if (!GetTempDir(&tmpdir))
     return false;
-  tmpdir.append(L"/com.google.chrome.XXXXXX");
+  AppendToPath(&tmpdir, kTempFileName);
+  std::string tmpdir_string = WideToUTF8(tmpdir);
   // this should be OK since mkdtemp just replaces characters in place
-  char* buffer = const_cast<char*>(WideToUTF8(tmpdir).c_str());
+  char* buffer = const_cast<char*>(tmpdir_string.c_str());
   char* dtemp = mkdtemp(buffer);
   if (!dtemp)
     return false;
   *new_temp_path = UTF8ToWide(dtemp);
   return true;
 }
 
 bool CreateDirectory(const std::wstring& full_path) {
   std::vector<std::wstring> components;
   PathComponents(full_path, &components);
@@ skipping 24 matching lines @@
   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 = open(WideToUTF8(filename).c_str(), O_WRONLY | O_CREAT | O_TRUNC, 
-                0666);
+  int fd = creat(WideToUTF8(filename).c_str(), 0666);
   if (fd < 0)
     return -1;
-  
-  int ret_value = write(fd, data, size);
+
+  // 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;      
+    }
+    bytes_written_total += bytes_written_partial;
+  } while (bytes_written_total < size);
+
   close(fd);
-  return ret_value;
+  return bytes_written_total;
 }
 
 // Gets the current working directory for the process.
 bool GetCurrentDirectory(std::wstring* dir) {
   char system_buffer[PATH_MAX] = "";
   getcwd(system_buffer, sizeof(system_buffer));
   *dir = UTF8ToWide(system_buffer);
   return true;
 }
 
@@ skipping 67 matching lines @@
     return Next();
   }
   
   // Level 0 is the top, which is always skipped.
   if (fts_ent->fts_level == 0)
     return Next();
   
   // Patterns are only matched on the items in the top-most directory.
   // (see Windows implementation)
   if (fts_ent->fts_level == 1 && pattern_.length() > 0) {
-    const char* utf8_pattern = WideToUTF8(pattern_).c_str();
-    if (fnmatch(utf8_pattern, fts_ent->fts_path, 0) != 0) {
+    if (fnmatch(WideToUTF8(pattern_).c_str(), fts_ent->fts_path, 0) != 0) {
       if (fts_ent->fts_info == FTS_D)
         fts_set(fts_, fts_ent, FTS_SKIP);
       return Next();
     }
   }
   
   std::wstring cur_file(UTF8ToWide(fts_ent->fts_path));
   if (fts_ent->fts_info == FTS_D) {
     // If not recursive, then prune children.
     if (!recursive_)
       fts_set(fts_, fts_ent, FTS_SKIP);
     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