base/process/process_posix.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/process/process.h"
   6
   7 #include <sys/resource.h>
   8 #include <sys/time.h>
   9 #include <sys/types.h>
  10
  11 #include "base/logging.h"
  12 #include "base/process/kill.h"
  13
  14 namespace base {
  15
  16 Process::Process(ProcessHandle handle) : process_(handle) {
  17   CHECK_NE(handle, GetCurrentProcessHandle());
  18 }
  19
  20 Process::Process(RValue other)
  21     : process_(other.object->process_) {
  22   other.object->Close();
  23 }
  24
  25 Process& Process::operator=(RValue other) {
  26   if (this != other.object) {
  27     process_ = other.object->process_;
  28     other.object->Close();
  29   }
  30   return *this;
  31 }
  32
  33 // static
  34 Process Process::Current() {
  35   Process process;
  36   process.process_ = GetCurrentProcessHandle();
  37   return process.Pass();
  38 }
  39
  40 #if !defined(OS_LINUX)
  41 // static
  42 bool Process::CanBackgroundProcesses() {
  43   return false;
  44 }
  45 #endif  // !defined(OS_LINUX)
  46
  47 bool Process::IsValid() const {
  48   return process_ != kNullProcessHandle;
  49 }
  50
  51 ProcessHandle Process::Handle() const {
  52   return process_;
  53 }
  54
  55 Process Process::Duplicate() const {
  56   if (is_current())
  57     return Current();
  58
  59   return Process(process_);
  60 }
  61
  62 ProcessId Process::pid() const {
  63   DCHECK(IsValid());
  64   return GetProcId(process_);
  65 }
  66
  67 bool Process::is_current() const {
  68   return process_ == GetCurrentProcessHandle();
  69 }
  70
  71 void Process::Close() {
  72   process_ = kNullProcessHandle;
  73   // if the process wasn't terminated (so we waited) or the state
  74   // wasn't already collected w/ a wait from process_utils, we're gonna
  75   // end up w/ a zombie when it does finally exit.
  76 }
  77
  78 void Process::Terminate(int result_code) {
  79   // result_code isn't supportable.
  80   DCHECK(IsValid());
  81   // We don't wait here. It's the responsibility of other code to reap the
  82   // child.
  83   KillProcess(process_, result_code, false);
  84 }
  85
  86 #if !defined(OS_LINUX)
  87 bool Process::IsProcessBackgrounded() const {
  88   // See SetProcessBackgrounded().
  89   DCHECK(IsValid());
  90   return false;
  91 }
  92
  93 bool Process::SetProcessBackgrounded(bool value) {
  94   // POSIX only allows lowering the priority of a process, so if we
  95   // were to lower it we wouldn't be able to raise it back to its initial
  96   // priority.
  97   DCHECK(IsValid());
  98   return false;
  99 }
 100 #endif  // !defined(OS_LINUX)
 101
 102 int Process::GetPriority() const {
 103   DCHECK(IsValid());
 104   return getpriority(PRIO_PROCESS, process_);
 105 }
 106
 107 }  // namspace base