1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70


base / process / process_ios.cc [blame]

// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/process/process.h"

#include "base/threading/thread_restrictions.h"

namespace base {

namespace {

static Process::TerminateCallback g_terminate_callback = nullptr;
static Process::WaitForExitCallback g_wait_for_exit_callback = nullptr;

}  // namespace

bool WaitForExitWithTimeoutImpl(base::ProcessHandle handle,
                                int* exit_code,
                                base::TimeDelta timeout);

void Process::SetTerminationHooks(TerminateCallback terminate_callback,
                                  WaitForExitCallback wait_callback) {
  CHECK(!g_terminate_callback);
  CHECK(!g_wait_for_exit_callback);
  g_terminate_callback = terminate_callback;
  g_wait_for_exit_callback = wait_callback;
}

#if TARGET_OS_SIMULATOR
void Process::SetIsContentProcess() {
  content_process_ = true;
}

bool Process::IsContentProcess() const {
  return content_process_;
}
#endif

bool Process::Terminate(int exit_code, bool wait) const {
  // exit_code isn't supportable.
  DCHECK(IsValid());
  CHECK_GT(process_, 0);
#if TARGET_OS_SIMULATOR
  if (!content_process_) {
    return TerminateInternal(exit_code, wait);
  }
#endif
  CHECK(g_terminate_callback);
  return (*g_terminate_callback)(process_);
}

bool Process::WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) const {
  if (!timeout.is_zero()) {
    // Assert that this thread is allowed to wait below. This intentionally
    // doesn't use ScopedBlockingCallWithBaseSyncPrimitives because the process
    // being waited upon tends to itself be using the CPU and considering this
    // thread non-busy causes more issue than it fixes: http://crbug.com/905788
    internal::AssertBaseSyncPrimitivesAllowed();
  }

#if TARGET_OS_SIMULATOR
  if (!content_process_) {
    return WaitForExitWithTimeoutImpl(Handle(), exit_code, timeout);
  }
#endif
  return (*g_wait_for_exit_callback)(process_, exit_code, timeout);
}

}  // namespace base