Properly honor base::SharedMemory semantics for name="" to mean...

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 20 matching lines @@
   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(FilePath* path) {
   char full_path[PATH_MAX];
   if (realpath(path->value().c_str(), full_path) == NULL)
     return false;
   *path = FilePath(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 FilePath& path, bool recursive) {
   const char* path_str = path.value().c_str();
   struct stat64 file_info;
   int test = stat64(path_str, &file_info);
   if (test != 0) {
     // The Windows version defines this condition as success.
-    bool ret = (errno == ENOENT || errno == ENOTDIR); 
+    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);
 
   bool success = true;
   int ftsflags = FTS_PHYSICAL | FTS_NOSTAT;
   char top_dir[PATH_MAX];
@@ skipping 173 matching lines @@
     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;
-  
+
   FILETIME utc_filetime;
   if (!GetFileTime(file_handle, &utc_filetime, NULL, NULL))
     return false;
-  
+
   FILETIME local_filetime;
   if (!FileTimeToLocalFileTime(&utc_filetime, &local_filetime))
     return false;
-  
+
   return !!FileTimeToSystemTime(&local_filetime, creation_time);
 }
 
 bool GetFileCreationLocalTime(const std::string& filename,
                               LPSYSTEMTIME creation_time) {
   ScopedHandle file_handle(
-      CreateFile(filename.c_str(), GENERIC_READ, 
+      CreateFile(filename.c_str(), GENERIC_READ,
                  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(FilePath* path) {
-  if (!GetTempDir(path))
-    return false;
-
-  *path = path->Append(kTempFileName);
-  std::string tmpdir_string = path->value();
+// Creates and opens a temporary file in |directory|, returning the
+// file descriptor.  |path| is set to the temporary file path.
+// Note TODO(erikkay) comment in header for BlahFileName() calls; the
+// intent is to rename these files BlahFile() (since they create
+// files, not filenames).  This function does NOT unlink() the file.
+int CreateAndOpenFdForTemporaryFile(FilePath directory, FilePath* path) {
+  *path = directory.Append(kTempFileName);
+  const std::string& tmpdir_string = path->value();
   // this should be OK since mkstemp just replaces characters in place
   char* buffer = const_cast<char*>(tmpdir_string.c_str());
 
-  int fd = mkstemp(buffer);
+  return mkstemp(buffer);
+}
+
+bool CreateTemporaryFileName(FilePath* path) {
+  FilePath directory;
+  if (!GetTempDir(&directory))
+    return false;
+  int fd = CreateAndOpenFdForTemporaryFile(directory, path);
   if (fd < 0)
     return false;
-
   close(fd);
   return true;
 }
 
+FILE* CreateAndOpenTemporaryFile(FilePath* path) {
+  FilePath directory;
+  if (!GetTempDir(&directory))
+    return false;
+
+  int fd = CreateAndOpenFdForTemporaryFile(directory, path);
+  if (fd < 0)
+    return NULL;
+
+  FILE *fp = fdopen(fd, "a+");
+  return fp;
+}
+
+FILE* CreateAndOpenTemporaryShmemFile(FilePath* path) {
+  FilePath directory;
+  if (!GetShmemTempDir(&directory))
+    return false;
+
+  int fd = CreateAndOpenFdForTemporaryFile(directory, path);
+  if (fd < 0)
+    return NULL;
+
+  FILE *fp = fdopen(fd, "a+");
+  return fp;
+}
+
 bool CreateTemporaryFileNameInDir(const std::wstring& dir,
                                   std::wstring* temp_file) {
   // Not implemented yet.
   NOTREACHED();
   return false;
 }
 
 bool CreateNewTempDirectory(const FilePath::StringType& prefix,
                             FilePath* new_temp_path) {
   FilePath tmpdir;
@@ skipping 234 matching lines @@
     munmap(data_, length_);
   if (file_ != -1)
     close(file_);
 
   data_ = NULL;
   length_ = 0;
   file_ = -1;
 }
 
 } // namespace file_util