Revert of Implement ScopedFD in terms of ScopedGeneric.

base/file_util_posix.cc

 // Copyright (c) 2012 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 <libgen.h>
@@ skipping 15 matching lines @@
 #include "base/mac/foundation_util.h"
 #elif !defined(OS_CHROMEOS) && defined(USE_GLIB)
 #include <glib.h>  // for g_get_home_dir()
 #endif
 
 #include <fstream>
 
 #include "base/basictypes.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
-#include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 119 matching lines @@
 
 #if defined(OS_LINUX)
 // Determine if /dev/shm files can be mapped and then mprotect'd PROT_EXEC.
 // This depends on the mount options used for /dev/shm, which vary among
 // different Linux distributions and possibly local configuration.  It also
 // depends on details of kernel--ChromeOS uses the noexec option for /dev/shm
 // but its kernel allows mprotect with PROT_EXEC anyway.
 bool DetermineDevShmExecutable() {
   bool result = false;
   FilePath path;
-
-  ScopedFD fd(CreateAndOpenFdForTemporaryFile(FilePath("/dev/shm"), &path));
-  if (fd.is_valid()) {
+  int fd = CreateAndOpenFdForTemporaryFile(FilePath("/dev/shm"), &path);
+  if (fd >= 0) {
+    file_util::ScopedFD shm_fd_closer(&fd);
     DeleteFile(path, false);
     long sysconf_result = sysconf(_SC_PAGESIZE);
     CHECK_GE(sysconf_result, 0);
     size_t pagesize = static_cast<size_t>(sysconf_result);
     CHECK_GE(sizeof(pagesize), sizeof(sysconf_result));
-    void *mapping = mmap(NULL, pagesize, PROT_READ, MAP_SHARED, fd.get(), 0);
+    void *mapping = mmap(NULL, pagesize, PROT_READ, MAP_SHARED, fd, 0);
     if (mapping != MAP_FAILED) {
       if (mprotect(mapping, pagesize, PROT_READ | PROT_EXEC) == 0)
         result = true;
       munmap(mapping, pagesize);
     }
   }
   return result;
 }
 #endif  // defined(OS_LINUX)
 
@@ skipping 459 matching lines @@
   if (S_ISLNK(st.st_mode))
     return true;
   else
     return false;
 }
 
 bool GetFileInfo(const FilePath& file_path, File::Info* results) {
   stat_wrapper_t file_info;
 #if defined(OS_ANDROID)
   if (file_path.IsContentUri()) {
-    ScopedFD fd(OpenContentUriForRead(file_path));
-    if (!fd.is_valid())
+    int fd = OpenContentUriForRead(file_path);
+    if (fd < 0)
       return false;
-    if (CallFstat(fd.get(), &file_info) != 0)
+    file_util::ScopedFD scoped_fd(&fd);
+    if (CallFstat(fd, &file_info) != 0)
       return false;
   } else {
 #endif  // defined(OS_ANDROID)
     if (CallStat(file_path.value().c_str(), &file_info) != 0)
       return false;
 #if defined(OS_ANDROID)
   }
 #endif  // defined(OS_ANDROID)
   results->is_directory = S_ISDIR(file_info.st_mode);
   results->size = file_info.st_size;
@@ skipping 243 matching lines @@
     result = false;
   if (IGNORE_EINTR(close(outfile)) < 0)
     result = false;
 
   return result;
 }
 #endif  // !defined(OS_MACOSX)
 
 }  // namespace internal
 }  // namespace base