Split ProcessHandle and its related routines into base/process/process_handle.h.

base/process_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 <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
@@ skipping 144 matching lines @@
       RAW_LOG(FATAL, "Cound not fix sa_restorer.");
     }
 #endif  // !defined(NDEBUG)
   }
 }
 #endif  // !defined(OS_LINUX) ||
         // (!defined(__i386__) && !defined(__x86_64__) && !defined(__arm__))
 
 }  // anonymous namespace
 
-ProcessId GetCurrentProcId() {
-  return getpid();
-}
-
-ProcessHandle GetCurrentProcessHandle() {
-  return GetCurrentProcId();
-}
-
-bool OpenProcessHandle(ProcessId pid, ProcessHandle* handle) {
-  // On Posix platforms, process handles are the same as PIDs, so we
-  // don't need to do anything.
-  *handle = pid;
-  return true;
-}
-
-bool OpenPrivilegedProcessHandle(ProcessId pid, ProcessHandle* handle) {
-  // On POSIX permissions are checked for each operation on process,
-  // not when opening a "handle".
-  return OpenProcessHandle(pid, handle);
-}
-
-bool OpenProcessHandleWithAccess(ProcessId pid,
-                                 uint32 access_flags,
-                                 ProcessHandle* handle) {
-  // On POSIX permissions are checked for each operation on process,
-  // not when opening a "handle".
-  return OpenProcessHandle(pid, handle);
-}
-
-void CloseProcessHandle(ProcessHandle process) {
-  // See OpenProcessHandle, nothing to do.
-  return;
-}
-
-ProcessId GetProcId(ProcessHandle process) {
-  return process;
-}
-
 // A class to handle auto-closing of DIR*'s.
 class ScopedDIRClose {
  public:
   inline void operator()(DIR* x) const {
     if (x) {
       closedir(x);
     }
   }
 };
 typedef scoped_ptr_malloc<DIR, ScopedDIRClose> ScopedDIR;
 
 #if defined(OS_LINUX)
-  static const rlim_t kSystemDefaultMaxFds = 8192;
-  static const char kFDDir[] = "/proc/self/fd";
+static const char kFDDir[] = "/proc/self/fd";
 #elif defined(OS_MACOSX)
-  static const rlim_t kSystemDefaultMaxFds = 256;
-  static const char kFDDir[] = "/dev/fd";
+static const char kFDDir[] = "/dev/fd";
 #elif defined(OS_SOLARIS)
-  static const rlim_t kSystemDefaultMaxFds = 8192;
-  static const char kFDDir[] = "/dev/fd";
+static const char kFDDir[] = "/dev/fd";
 #elif defined(OS_FREEBSD)
-  static const rlim_t kSystemDefaultMaxFds = 8192;
-  static const char kFDDir[] = "/dev/fd";
+static const char kFDDir[] = "/dev/fd";
 #elif defined(OS_OPENBSD)
-  static const rlim_t kSystemDefaultMaxFds = 256;
-  static const char kFDDir[] = "/dev/fd";
+static const char kFDDir[] = "/dev/fd";
 #elif defined(OS_ANDROID)
-  static const rlim_t kSystemDefaultMaxFds = 1024;
-  static const char kFDDir[] = "/proc/self/fd";
+static const char kFDDir[] = "/proc/self/fd";
 #endif
 
-size_t GetMaxFds() {
-  rlim_t max_fds;
-  struct rlimit nofile;
-  if (getrlimit(RLIMIT_NOFILE, &nofile)) {
-    // getrlimit failed. Take a best guess.
-    max_fds = kSystemDefaultMaxFds;
-    RAW_LOG(ERROR, "getrlimit(RLIMIT_NOFILE) failed");
-  } else {
-    max_fds = nofile.rlim_cur;
-  }
-
-  if (max_fds > INT_MAX)
-    max_fds = INT_MAX;
-
-  return static_cast<size_t>(max_fds);
-}
-
 void CloseSuperfluousFds(const base::InjectiveMultimap& saved_mapping) {
   // DANGER: no calls to malloc are allowed from now on:
   // http://crbug.com/36678
 
   // Get the maximum number of FDs possible.
   size_t max_fds = GetMaxFds();
 
   DirReaderPosix fd_dir(kFDDir);
   if (!fd_dir.IsValid()) {
     // Fallback case: Try every possible fd.
@@ skipping 517 matching lines @@
                               std::string* output,
                               int* exit_code) {
   // Run |execve()| with the current environment and store "unlimited" data.
   GetAppOutputInternalResult result = GetAppOutputInternal(
       cl.argv(), NULL, output, std::numeric_limits<std::size_t>::max(), true,
       exit_code);
   return result == EXECUTE_SUCCESS;
 }
 
 }  // namespace base