MultiProcessTest: Update SpawnChild* to return a Process.
We should not be dealing with raw handles. BUG=417532 Review URL: https://codereview.chromium.org/843113003 Cr-Commit-Position: refs/heads/master@{#311127}
This commit is contained in:
base
debug
memory
metrics
process
test
chrome
browser
printing
cloud_print
common
components/browser_watcher
content/common
ipc
mojo/edk/test
sandbox/mac
@ -146,9 +146,10 @@ MULTIPROCESS_TEST_MAIN(MismatchedMallocChildProcess) {
|
||||
// and e.g. mismatched new[]/delete would cause a hang because
|
||||
// of re-entering malloc.
|
||||
TEST_F(StackTraceTest, AsyncSignalUnsafeSignalHandlerHang) {
|
||||
ProcessHandle child = SpawnChild("MismatchedMallocChildProcess");
|
||||
ASSERT_NE(kNullProcessHandle, child);
|
||||
ASSERT_TRUE(WaitForSingleProcess(child, TestTimeouts::action_timeout()));
|
||||
Process child = SpawnChild("MismatchedMallocChildProcess");
|
||||
ASSERT_TRUE(child.IsValid());
|
||||
ASSERT_TRUE(WaitForSingleProcess(child.Handle(),
|
||||
TestTimeouts::action_timeout()));
|
||||
}
|
||||
#endif // !defined(OS_IOS)
|
||||
|
||||
|
@ -699,15 +699,15 @@ const char* const SharedMemoryProcessTest::s_test_name_ = "MPMem";
|
||||
TEST_F(SharedMemoryProcessTest, Tasks) {
|
||||
SharedMemoryProcessTest::CleanUp();
|
||||
|
||||
ProcessHandle handles[kNumTasks];
|
||||
Process processes[kNumTasks];
|
||||
for (int index = 0; index < kNumTasks; ++index) {
|
||||
handles[index] = SpawnChild("SharedMemoryTestMain");
|
||||
ASSERT_TRUE(handles[index]);
|
||||
processes[index] = SpawnChild("SharedMemoryTestMain");
|
||||
ASSERT_TRUE(processes[index].IsValid());
|
||||
}
|
||||
|
||||
int exit_code = 0;
|
||||
for (int index = 0; index < kNumTasks; ++index) {
|
||||
EXPECT_TRUE(WaitForExitCode(handles[index], &exit_code));
|
||||
EXPECT_TRUE(processes[index].WaitForExit(&exit_code));
|
||||
EXPECT_EQ(0, exit_code);
|
||||
}
|
||||
|
||||
|
@ -200,19 +200,19 @@ TEST_F(StatsTableTest, DISABLED_MultipleProcesses) {
|
||||
// Spin up a set of processes to go bang on the various counters.
|
||||
// After we join the processes, we'll make sure the counters
|
||||
// contain the values we expected.
|
||||
ProcessHandle procs[kMaxProcs];
|
||||
Process procs[kMaxProcs];
|
||||
|
||||
// Spawn the processes.
|
||||
for (int16 index = 0; index < kMaxProcs; index++) {
|
||||
procs[index] = SpawnChild("StatsTableMultipleProcessMain");
|
||||
EXPECT_NE(kNullProcessHandle, procs[index]);
|
||||
EXPECT_TRUE(procs[index].IsValid());
|
||||
}
|
||||
|
||||
// Wait for the processes to finish.
|
||||
for (int index = 0; index < kMaxProcs; index++) {
|
||||
EXPECT_TRUE(WaitForSingleProcess(
|
||||
procs[index], base::TimeDelta::FromMinutes(1)));
|
||||
CloseProcessHandle(procs[index]);
|
||||
EXPECT_TRUE(WaitForSingleProcess(procs[index].Handle(),
|
||||
base::TimeDelta::FromMinutes(1)));
|
||||
procs[index].Close();
|
||||
}
|
||||
|
||||
StatsCounter zero_counter(kCounterZero);
|
||||
|
@ -142,11 +142,10 @@ MULTIPROCESS_TEST_MAIN(SimpleChildProcess) {
|
||||
|
||||
// TODO(viettrungluu): This should be in a "MultiProcessTestTest".
|
||||
TEST_F(ProcessUtilTest, SpawnChild) {
|
||||
base::ProcessHandle handle = SpawnChild("SimpleChildProcess");
|
||||
ASSERT_NE(base::kNullProcessHandle, handle);
|
||||
EXPECT_TRUE(base::WaitForSingleProcess(
|
||||
handle, TestTimeouts::action_max_timeout()));
|
||||
base::CloseProcessHandle(handle);
|
||||
base::Process process = SpawnChild("SimpleChildProcess");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
EXPECT_TRUE(base::WaitForSingleProcess(process.Handle(),
|
||||
TestTimeouts::action_max_timeout()));
|
||||
}
|
||||
|
||||
MULTIPROCESS_TEST_MAIN(SlowChildProcess) {
|
||||
@ -158,12 +157,11 @@ TEST_F(ProcessUtilTest, KillSlowChild) {
|
||||
const std::string signal_file =
|
||||
ProcessUtilTest::GetSignalFilePath(kSignalFileSlow);
|
||||
remove(signal_file.c_str());
|
||||
base::ProcessHandle handle = SpawnChild("SlowChildProcess");
|
||||
ASSERT_NE(base::kNullProcessHandle, handle);
|
||||
base::Process process = SpawnChild("SlowChildProcess");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
SignalChildren(signal_file.c_str());
|
||||
EXPECT_TRUE(base::WaitForSingleProcess(
|
||||
handle, TestTimeouts::action_max_timeout()));
|
||||
base::CloseProcessHandle(handle);
|
||||
EXPECT_TRUE(base::WaitForSingleProcess(process.Handle(),
|
||||
TestTimeouts::action_max_timeout()));
|
||||
remove(signal_file.c_str());
|
||||
}
|
||||
|
||||
@ -172,21 +170,20 @@ TEST_F(ProcessUtilTest, DISABLED_GetTerminationStatusExit) {
|
||||
const std::string signal_file =
|
||||
ProcessUtilTest::GetSignalFilePath(kSignalFileSlow);
|
||||
remove(signal_file.c_str());
|
||||
base::ProcessHandle handle = SpawnChild("SlowChildProcess");
|
||||
ASSERT_NE(base::kNullProcessHandle, handle);
|
||||
base::Process process = SpawnChild("SlowChildProcess");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
|
||||
int exit_code = 42;
|
||||
EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
|
||||
base::GetTerminationStatus(handle, &exit_code));
|
||||
base::GetTerminationStatus(process.Handle(), &exit_code));
|
||||
EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
|
||||
|
||||
SignalChildren(signal_file.c_str());
|
||||
exit_code = 42;
|
||||
base::TerminationStatus status =
|
||||
WaitForChildTermination(handle, &exit_code);
|
||||
WaitForChildTermination(process.Handle(), &exit_code);
|
||||
EXPECT_EQ(base::TERMINATION_STATUS_NORMAL_TERMINATION, status);
|
||||
EXPECT_EQ(0, exit_code);
|
||||
base::CloseProcessHandle(handle);
|
||||
remove(signal_file.c_str());
|
||||
}
|
||||
|
||||
@ -195,12 +192,11 @@ TEST_F(ProcessUtilTest, DISABLED_GetTerminationStatusExit) {
|
||||
TEST_F(ProcessUtilTest, GetProcId) {
|
||||
base::ProcessId id1 = base::GetProcId(GetCurrentProcess());
|
||||
EXPECT_NE(0ul, id1);
|
||||
base::ProcessHandle handle = SpawnChild("SimpleChildProcess");
|
||||
ASSERT_NE(base::kNullProcessHandle, handle);
|
||||
base::ProcessId id2 = base::GetProcId(handle);
|
||||
base::Process process = SpawnChild("SimpleChildProcess");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
base::ProcessId id2 = process.pid();
|
||||
EXPECT_NE(0ul, id2);
|
||||
EXPECT_NE(id1, id2);
|
||||
base::CloseProcessHandle(handle);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -239,18 +235,18 @@ TEST_F(ProcessUtilTest, MAYBE_GetTerminationStatusCrash) {
|
||||
const std::string signal_file =
|
||||
ProcessUtilTest::GetSignalFilePath(kSignalFileCrash);
|
||||
remove(signal_file.c_str());
|
||||
base::ProcessHandle handle = SpawnChild("CrashingChildProcess");
|
||||
ASSERT_NE(base::kNullProcessHandle, handle);
|
||||
base::Process process = SpawnChild("CrashingChildProcess");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
|
||||
int exit_code = 42;
|
||||
EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
|
||||
base::GetTerminationStatus(handle, &exit_code));
|
||||
base::GetTerminationStatus(process.Handle(), &exit_code));
|
||||
EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
|
||||
|
||||
SignalChildren(signal_file.c_str());
|
||||
exit_code = 42;
|
||||
base::TerminationStatus status =
|
||||
WaitForChildTermination(handle, &exit_code);
|
||||
WaitForChildTermination(process.Handle(), &exit_code);
|
||||
EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_CRASHED, status);
|
||||
|
||||
#if defined(OS_WIN)
|
||||
@ -261,7 +257,6 @@ TEST_F(ProcessUtilTest, MAYBE_GetTerminationStatusCrash) {
|
||||
int signal = WTERMSIG(exit_code);
|
||||
EXPECT_EQ(SIGSEGV, signal);
|
||||
#endif
|
||||
base::CloseProcessHandle(handle);
|
||||
|
||||
// Reset signal handlers back to "normal".
|
||||
base::debug::EnableInProcessStackDumping();
|
||||
@ -286,18 +281,18 @@ TEST_F(ProcessUtilTest, GetTerminationStatusKill) {
|
||||
const std::string signal_file =
|
||||
ProcessUtilTest::GetSignalFilePath(kSignalFileKill);
|
||||
remove(signal_file.c_str());
|
||||
base::ProcessHandle handle = SpawnChild("KilledChildProcess");
|
||||
ASSERT_NE(base::kNullProcessHandle, handle);
|
||||
base::Process process = SpawnChild("KilledChildProcess");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
|
||||
int exit_code = 42;
|
||||
EXPECT_EQ(base::TERMINATION_STATUS_STILL_RUNNING,
|
||||
base::GetTerminationStatus(handle, &exit_code));
|
||||
base::GetTerminationStatus(process.Handle(), &exit_code));
|
||||
EXPECT_EQ(kExpectedStillRunningExitCode, exit_code);
|
||||
|
||||
SignalChildren(signal_file.c_str());
|
||||
exit_code = 42;
|
||||
base::TerminationStatus status =
|
||||
WaitForChildTermination(handle, &exit_code);
|
||||
WaitForChildTermination(process.Handle(), &exit_code);
|
||||
EXPECT_EQ(base::TERMINATION_STATUS_PROCESS_WAS_KILLED, status);
|
||||
#if defined(OS_WIN)
|
||||
EXPECT_EQ(kExpectedKilledExitCode, exit_code);
|
||||
@ -307,7 +302,6 @@ TEST_F(ProcessUtilTest, GetTerminationStatusKill) {
|
||||
int signal = WTERMSIG(exit_code);
|
||||
EXPECT_EQ(SIGKILL, signal);
|
||||
#endif
|
||||
base::CloseProcessHandle(handle);
|
||||
remove(signal_file.c_str());
|
||||
}
|
||||
|
||||
@ -535,9 +529,9 @@ int ProcessUtilTest::CountOpenFDsInChild() {
|
||||
fd_mapping_vec.push_back(std::pair<int, int>(fds[1], kChildPipe));
|
||||
base::LaunchOptions options;
|
||||
options.fds_to_remap = &fd_mapping_vec;
|
||||
base::ProcessHandle handle =
|
||||
base::Process process =
|
||||
SpawnChildWithOptions("ProcessUtilsLeakFDChildProcess", options);
|
||||
CHECK(handle);
|
||||
CHECK(process.IsValid());
|
||||
int ret = IGNORE_EINTR(close(fds[1]));
|
||||
DPCHECK(ret == 0);
|
||||
|
||||
@ -549,11 +543,12 @@ int ProcessUtilTest::CountOpenFDsInChild() {
|
||||
|
||||
#if defined(THREAD_SANITIZER)
|
||||
// Compiler-based ThreadSanitizer makes this test slow.
|
||||
CHECK(base::WaitForSingleProcess(handle, base::TimeDelta::FromSeconds(3)));
|
||||
CHECK(base::WaitForSingleProcess(process.Handle(),
|
||||
base::TimeDelta::FromSeconds(3)));
|
||||
#else
|
||||
CHECK(base::WaitForSingleProcess(handle, base::TimeDelta::FromSeconds(1)));
|
||||
CHECK(base::WaitForSingleProcess(process.Handle(),
|
||||
base::TimeDelta::FromSeconds(1)));
|
||||
#endif
|
||||
base::CloseProcessHandle(handle);
|
||||
ret = IGNORE_EINTR(close(fds[0]));
|
||||
DPCHECK(ret == 0);
|
||||
|
||||
@ -888,7 +883,7 @@ bool IsProcessDead(base::ProcessHandle child) {
|
||||
}
|
||||
|
||||
TEST_F(ProcessUtilTest, DelayedTermination) {
|
||||
base::Process child_process(SpawnChild("process_util_test_never_die"));
|
||||
base::Process child_process = SpawnChild("process_util_test_never_die");
|
||||
ASSERT_TRUE(child_process.IsValid());
|
||||
base::EnsureProcessTerminated(child_process.Duplicate());
|
||||
base::WaitForSingleProcess(child_process.Handle(),
|
||||
@ -906,7 +901,7 @@ MULTIPROCESS_TEST_MAIN(process_util_test_never_die) {
|
||||
}
|
||||
|
||||
TEST_F(ProcessUtilTest, ImmediateTermination) {
|
||||
base::Process child_process(SpawnChild("process_util_test_die_immediately"));
|
||||
base::Process child_process = SpawnChild("process_util_test_die_immediately");
|
||||
ASSERT_TRUE(child_process.IsValid());
|
||||
// Give it time to die.
|
||||
sleep(2);
|
||||
|
@ -10,7 +10,7 @@
|
||||
namespace base {
|
||||
|
||||
#if !defined(OS_ANDROID)
|
||||
ProcessHandle SpawnMultiProcessTestChild(
|
||||
Process SpawnMultiProcessTestChild(
|
||||
const std::string& procname,
|
||||
const CommandLine& base_command_line,
|
||||
const LaunchOptions& options) {
|
||||
@ -21,9 +21,7 @@ ProcessHandle SpawnMultiProcessTestChild(
|
||||
if (!command_line.HasSwitch(switches::kTestChildProcess))
|
||||
command_line.AppendSwitchASCII(switches::kTestChildProcess, procname);
|
||||
|
||||
ProcessHandle handle = kNullProcessHandle;
|
||||
LaunchProcess(command_line, options, &handle);
|
||||
return handle;
|
||||
return LaunchProcess(command_line, options);
|
||||
}
|
||||
#endif // !defined(OS_ANDROID)
|
||||
|
||||
@ -36,7 +34,7 @@ CommandLine GetMultiProcessTestChildBaseCommandLine() {
|
||||
MultiProcessTest::MultiProcessTest() {
|
||||
}
|
||||
|
||||
ProcessHandle MultiProcessTest::SpawnChild(const std::string& procname) {
|
||||
Process MultiProcessTest::SpawnChild(const std::string& procname) {
|
||||
LaunchOptions options;
|
||||
#if defined(OS_WIN)
|
||||
options.start_hidden = true;
|
||||
@ -44,7 +42,7 @@ ProcessHandle MultiProcessTest::SpawnChild(const std::string& procname) {
|
||||
return SpawnChildWithOptions(procname, options);
|
||||
}
|
||||
|
||||
ProcessHandle MultiProcessTest::SpawnChildWithOptions(
|
||||
Process MultiProcessTest::SpawnChildWithOptions(
|
||||
const std::string& procname,
|
||||
const LaunchOptions& options) {
|
||||
return SpawnMultiProcessTestChild(procname, MakeCmdLine(procname), options);
|
||||
|
@ -9,7 +9,7 @@
|
||||
|
||||
#include "base/basictypes.h"
|
||||
#include "base/process/launch.h"
|
||||
#include "base/process/process_handle.h"
|
||||
#include "base/process/process.h"
|
||||
#include "build/build_config.h"
|
||||
#include "testing/platform_test.h"
|
||||
|
||||
@ -58,7 +58,7 @@ class CommandLine;
|
||||
// |command_line| should be as provided by
|
||||
// |GetMultiProcessTestChildBaseCommandLine()| (below), possibly with arguments
|
||||
// added. Note: On Windows, you probably want to set |options.start_hidden|.
|
||||
ProcessHandle SpawnMultiProcessTestChild(
|
||||
Process SpawnMultiProcessTestChild(
|
||||
const std::string& procname,
|
||||
const CommandLine& command_line,
|
||||
const LaunchOptions& options);
|
||||
@ -105,14 +105,14 @@ class MultiProcessTest : public PlatformTest {
|
||||
// // do client work here
|
||||
// }
|
||||
//
|
||||
// Returns the handle to the child, or NULL on failure
|
||||
ProcessHandle SpawnChild(const std::string& procname);
|
||||
// Returns the child process.
|
||||
Process SpawnChild(const std::string& procname);
|
||||
|
||||
// Run a child process using the given launch options.
|
||||
//
|
||||
// Note: On Windows, you probably want to set |options.start_hidden|.
|
||||
ProcessHandle SpawnChildWithOptions(const std::string& procname,
|
||||
const LaunchOptions& options);
|
||||
Process SpawnChildWithOptions(const std::string& procname,
|
||||
const LaunchOptions& options);
|
||||
|
||||
// Set up the command line used to spawn the child process.
|
||||
// Override this to add things to the command line (calling this first in the
|
||||
|
@ -19,9 +19,9 @@ namespace base {
|
||||
// and we don't have an executable to exec*. This implementation does the bare
|
||||
// minimum to execute the method specified by procname (in the child process).
|
||||
// - All options except |fds_to_remap| are ignored.
|
||||
ProcessHandle SpawnMultiProcessTestChild(const std::string& procname,
|
||||
const CommandLine& base_command_line,
|
||||
const LaunchOptions& options) {
|
||||
Process SpawnMultiProcessTestChild(const std::string& procname,
|
||||
const CommandLine& base_command_line,
|
||||
const LaunchOptions& options) {
|
||||
// TODO(viettrungluu): The FD-remapping done below is wrong in the presence of
|
||||
// cycles (e.g., fd1 -> fd2, fd2 -> fd1). crbug.com/326576
|
||||
FileHandleMappingVector empty;
|
||||
@ -32,11 +32,11 @@ ProcessHandle SpawnMultiProcessTestChild(const std::string& procname,
|
||||
|
||||
if (pid < 0) {
|
||||
PLOG(ERROR) << "fork";
|
||||
return kNullProcessHandle;
|
||||
return Process();
|
||||
}
|
||||
if (pid > 0) {
|
||||
// Parent process.
|
||||
return pid;
|
||||
return Process(pid);
|
||||
}
|
||||
// Child process.
|
||||
base::hash_set<int> fds_to_keep_open;
|
||||
@ -69,7 +69,7 @@ ProcessHandle SpawnMultiProcessTestChild(const std::string& procname,
|
||||
command_line->AppendSwitchASCII(switches::kTestChildProcess, procname);
|
||||
|
||||
_exit(multi_process_function_list::InvokeChildProcessTest(procname));
|
||||
return 0;
|
||||
return Process();
|
||||
}
|
||||
|
||||
} // namespace base
|
||||
|
@ -10,6 +10,7 @@
|
||||
#include "base/command_line.h"
|
||||
#include "base/message_loop/message_loop.h"
|
||||
#include "base/process/kill.h"
|
||||
#include "base/process/process.h"
|
||||
#include "base/rand_util.h"
|
||||
#include "base/synchronization/waitable_event.h"
|
||||
#include "base/test/multiprocess_test.h"
|
||||
@ -308,10 +309,10 @@ class CloudPrintProxyPolicyStartupTest : public base::MultiProcessTest,
|
||||
scoped_refptr<base::MessageLoopProxy> IOMessageLoopProxy() {
|
||||
return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
|
||||
}
|
||||
base::ProcessHandle Launch(const std::string& name);
|
||||
base::Process Launch(const std::string& name);
|
||||
void WaitForConnect();
|
||||
bool Send(IPC::Message* message);
|
||||
void ShutdownAndWaitForExitWithTimeout(base::ProcessHandle handle);
|
||||
void ShutdownAndWaitForExitWithTimeout(base::Process process);
|
||||
|
||||
// IPC::Listener implementation
|
||||
bool OnMessageReceived(const IPC::Message& message) override { return false; }
|
||||
@ -430,7 +431,7 @@ void CloudPrintProxyPolicyStartupTest::TearDown() {
|
||||
TestingBrowserProcess::DeleteInstance();
|
||||
}
|
||||
|
||||
base::ProcessHandle CloudPrintProxyPolicyStartupTest::Launch(
|
||||
base::Process CloudPrintProxyPolicyStartupTest::Launch(
|
||||
const std::string& name) {
|
||||
EXPECT_FALSE(CheckServiceProcessReady());
|
||||
|
||||
@ -450,12 +451,12 @@ base::ProcessHandle CloudPrintProxyPolicyStartupTest::Launch(
|
||||
kPrimaryIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
|
||||
base::LaunchOptions options;
|
||||
options.fds_to_remap = &ipc_file_list;
|
||||
base::ProcessHandle handle = SpawnChildWithOptions(name, options);
|
||||
base::Process process = SpawnChildWithOptions(name, options);
|
||||
#else
|
||||
base::ProcessHandle handle = SpawnChild(name);
|
||||
base::Process process = SpawnChild(name);
|
||||
#endif
|
||||
EXPECT_TRUE(handle);
|
||||
return handle;
|
||||
EXPECT_TRUE(process.IsValid());
|
||||
return process.Pass();
|
||||
}
|
||||
|
||||
void CloudPrintProxyPolicyStartupTest::WaitForConnect() {
|
||||
@ -474,16 +475,14 @@ bool CloudPrintProxyPolicyStartupTest::Send(IPC::Message* message) {
|
||||
}
|
||||
|
||||
void CloudPrintProxyPolicyStartupTest::ShutdownAndWaitForExitWithTimeout(
|
||||
base::ProcessHandle handle) {
|
||||
base::Process process) {
|
||||
ASSERT_TRUE(Send(new ServiceMsg_Shutdown()));
|
||||
|
||||
int exit_code = -100;
|
||||
bool exited =
|
||||
base::WaitForExitCodeWithTimeout(handle, &exit_code,
|
||||
TestTimeouts::action_timeout());
|
||||
bool exited = process.WaitForExitWithTimeout(TestTimeouts::action_timeout(),
|
||||
&exit_code);
|
||||
EXPECT_TRUE(exited);
|
||||
EXPECT_EQ(exit_code, 0);
|
||||
base::CloseProcessHandle(handle);
|
||||
}
|
||||
|
||||
void CloudPrintProxyPolicyStartupTest::OnChannelConnected(int32 peer_pid) {
|
||||
@ -511,10 +510,10 @@ TEST_F(CloudPrintProxyPolicyStartupTest, StartAndShutdown) {
|
||||
// constructed.
|
||||
chrome::TestingIOThreadState testing_io_thread_state;
|
||||
|
||||
base::ProcessHandle handle =
|
||||
base::Process process =
|
||||
Launch("CloudPrintMockService_StartEnabledWaitForQuit");
|
||||
WaitForConnect();
|
||||
ShutdownAndWaitForExitWithTimeout(handle);
|
||||
ShutdownAndWaitForExitWithTimeout(process.Pass());
|
||||
content::RunAllPendingInMessageLoop();
|
||||
}
|
||||
|
||||
@ -527,7 +526,7 @@ KeyedService* CloudPrintProxyServiceFactoryForPolicyTest(
|
||||
}
|
||||
|
||||
TEST_F(CloudPrintProxyPolicyStartupTest, StartBrowserWithoutPolicy) {
|
||||
base::ProcessHandle handle =
|
||||
base::Process process =
|
||||
Launch("CloudPrintMockService_StartEnabledWaitForQuit");
|
||||
|
||||
// Setup the Browser Process with a full IOThread::Globals.
|
||||
@ -571,13 +570,13 @@ TEST_F(CloudPrintProxyPolicyStartupTest, StartBrowserWithoutPolicy) {
|
||||
EXPECT_EQ(MockServiceIPCServer::EnabledUserId(),
|
||||
prefs->GetString(prefs::kCloudPrintEmail));
|
||||
|
||||
ShutdownAndWaitForExitWithTimeout(handle);
|
||||
ShutdownAndWaitForExitWithTimeout(process.Pass());
|
||||
content::RunAllPendingInMessageLoop();
|
||||
profile_manager.DeleteTestingProfile("StartBrowserWithoutPolicy");
|
||||
}
|
||||
|
||||
TEST_F(CloudPrintProxyPolicyStartupTest, StartBrowserWithPolicy) {
|
||||
base::ProcessHandle handle =
|
||||
base::Process process =
|
||||
Launch("CloudPrintMockService_StartEnabledExpectDisabled");
|
||||
|
||||
TestingBrowserProcess* browser_process =
|
||||
@ -622,7 +621,7 @@ TEST_F(CloudPrintProxyPolicyStartupTest, StartBrowserWithPolicy) {
|
||||
|
||||
EXPECT_EQ("", prefs->GetString(prefs::kCloudPrintEmail));
|
||||
|
||||
ShutdownAndWaitForExitWithTimeout(handle);
|
||||
ShutdownAndWaitForExitWithTimeout(process.Pass());
|
||||
content::RunAllPendingInMessageLoop();
|
||||
profile_manager.DeleteTestingProfile("StartBrowserWithPolicy");
|
||||
}
|
||||
|
@ -51,20 +51,20 @@ std::string MultiProcessLockTest::GenerateLockName() {
|
||||
|
||||
void MultiProcessLockTest::ExpectLockIsLocked(const std::string &name) {
|
||||
ScopedEnvironmentVariable var(kLockEnviromentVarName, name);
|
||||
base::ProcessHandle handle = SpawnChild("MultiProcessLockTryFailMain");
|
||||
ASSERT_TRUE(handle);
|
||||
base::Process process = SpawnChild("MultiProcessLockTryFailMain");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
int exit_code = 0;
|
||||
EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
|
||||
EXPECT_TRUE(process.WaitForExit(&exit_code));
|
||||
EXPECT_EQ(exit_code, 0);
|
||||
}
|
||||
|
||||
void MultiProcessLockTest::ExpectLockIsUnlocked(
|
||||
const std::string &name) {
|
||||
ScopedEnvironmentVariable var(kLockEnviromentVarName, name);
|
||||
base::ProcessHandle handle = SpawnChild("MultiProcessLockTrySucceedMain");
|
||||
ASSERT_TRUE(handle);
|
||||
base::Process process = SpawnChild("MultiProcessLockTrySucceedMain");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
int exit_code = 0;
|
||||
EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
|
||||
EXPECT_TRUE(process.WaitForExit(&exit_code));
|
||||
EXPECT_EQ(exit_code, 0);
|
||||
}
|
||||
|
||||
|
@ -94,10 +94,10 @@ void ServiceProcessStateTest::SetUp() {
|
||||
}
|
||||
|
||||
void ServiceProcessStateTest::LaunchAndWait(const std::string& name) {
|
||||
base::ProcessHandle handle = SpawnChild(name);
|
||||
ASSERT_TRUE(handle);
|
||||
base::Process process = SpawnChild(name);
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
int exit_code = 0;
|
||||
ASSERT_TRUE(base::WaitForExitCode(handle, &exit_code));
|
||||
ASSERT_TRUE(process.WaitForExit(&exit_code));
|
||||
ASSERT_EQ(exit_code, 0);
|
||||
}
|
||||
|
||||
@ -187,8 +187,8 @@ TEST_F(ServiceProcessStateTest, DISABLED_SharedMem) {
|
||||
}
|
||||
|
||||
TEST_F(ServiceProcessStateTest, MAYBE_ForceShutdown) {
|
||||
base::ProcessHandle handle = SpawnChild("ServiceProcessStateTestShutdown");
|
||||
ASSERT_TRUE(handle);
|
||||
base::Process process = SpawnChild("ServiceProcessStateTestShutdown");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
for (int i = 0; !CheckServiceProcessReady() && i < 10; ++i) {
|
||||
base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
|
||||
}
|
||||
@ -198,9 +198,8 @@ TEST_F(ServiceProcessStateTest, MAYBE_ForceShutdown) {
|
||||
ASSERT_TRUE(GetServiceProcessData(&version, &pid));
|
||||
ASSERT_TRUE(ForceServiceProcessShutdown(version, pid));
|
||||
int exit_code = 0;
|
||||
ASSERT_TRUE(base::WaitForExitCodeWithTimeout(handle,
|
||||
&exit_code, TestTimeouts::action_max_timeout()));
|
||||
base::CloseProcessHandle(handle);
|
||||
ASSERT_TRUE(process.WaitForExitWithTimeout(TestTimeouts::action_max_timeout(),
|
||||
&exit_code));
|
||||
ASSERT_EQ(exit_code, 0);
|
||||
}
|
||||
|
||||
|
@ -50,8 +50,7 @@ class ScopedSleeperProcess {
|
||||
base::CommandLine cmd_line(base::GetMultiProcessTestChildBaseCommandLine());
|
||||
base::LaunchOptions options;
|
||||
options.start_hidden = true;
|
||||
process_ = base::Process(
|
||||
base::SpawnMultiProcessTestChild("Sleeper", cmd_line, options));
|
||||
process_ = base::SpawnMultiProcessTestChild("Sleeper", cmd_line, options);
|
||||
ASSERT_TRUE(process_.IsValid());
|
||||
}
|
||||
|
||||
|
@ -34,14 +34,14 @@ class MacDirAccessSandboxTest : public base::MultiProcessTest {
|
||||
public:
|
||||
bool CheckSandbox(const std::string& directory_to_try) {
|
||||
setenv(kSandboxAccessPathKey, directory_to_try.c_str(), 1);
|
||||
base::ProcessHandle child_process = SpawnChild("mac_sandbox_path_access");
|
||||
if (child_process == base::kNullProcessHandle) {
|
||||
base::Process child_process = SpawnChild("mac_sandbox_path_access");
|
||||
if (!child_process.IsValid()) {
|
||||
LOG(WARNING) << "SpawnChild failed";
|
||||
return false;
|
||||
}
|
||||
int code = -1;
|
||||
if (!base::WaitForExitCode(child_process, &code)) {
|
||||
LOG(WARNING) << "base::WaitForExitCode failed";
|
||||
if (!child_process.WaitForExit(&code)) {
|
||||
LOG(WARNING) << "Process::WaitForExit failed";
|
||||
return false;
|
||||
}
|
||||
return code == 0;
|
||||
|
@ -77,14 +77,14 @@ bool MacSandboxTest::RunTestInSandbox(SandboxType sandbox_type,
|
||||
if (test_data)
|
||||
setenv(kTestDataKey, test_data, 1);
|
||||
|
||||
base::ProcessHandle child_process = SpawnChild("mac_sandbox_test_runner");
|
||||
if (child_process == base::kNullProcessHandle) {
|
||||
base::Process child_process = SpawnChild("mac_sandbox_test_runner");
|
||||
if (!child_process.IsValid()) {
|
||||
LOG(WARNING) << "SpawnChild failed";
|
||||
return false;
|
||||
}
|
||||
int code = -1;
|
||||
if (!base::WaitForExitCode(child_process, &code)) {
|
||||
LOG(WARNING) << "base::WaitForExitCode failed";
|
||||
if (!child_process.WaitForExit(&code)) {
|
||||
LOG(WARNING) << "Process::WaitForExit failed";
|
||||
return false;
|
||||
}
|
||||
return code == 0;
|
||||
|
@ -293,8 +293,8 @@ TEST_F(IPCChannelPosixTest, AdvancedConnected) {
|
||||
ASSERT_TRUE(channel->AcceptsConnections());
|
||||
ASSERT_FALSE(channel->HasAcceptedConnection());
|
||||
|
||||
base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
|
||||
ASSERT_TRUE(handle);
|
||||
base::Process process = SpawnChild("IPCChannelPosixTestConnectionProc");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
SpinRunLoop(TestTimeouts::action_max_timeout());
|
||||
ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
|
||||
ASSERT_TRUE(channel->HasAcceptedConnection());
|
||||
@ -304,7 +304,7 @@ TEST_F(IPCChannelPosixTest, AdvancedConnected) {
|
||||
channel->Send(message);
|
||||
SpinRunLoop(TestTimeouts::action_timeout());
|
||||
int exit_code = 0;
|
||||
EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
|
||||
EXPECT_TRUE(process.WaitForExit(&exit_code));
|
||||
EXPECT_EQ(0, exit_code);
|
||||
ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
|
||||
ASSERT_FALSE(channel->HasAcceptedConnection());
|
||||
@ -323,16 +323,16 @@ TEST_F(IPCChannelPosixTest, ResetState) {
|
||||
ASSERT_TRUE(channel->AcceptsConnections());
|
||||
ASSERT_FALSE(channel->HasAcceptedConnection());
|
||||
|
||||
base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
|
||||
ASSERT_TRUE(handle);
|
||||
base::Process process = SpawnChild("IPCChannelPosixTestConnectionProc");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
SpinRunLoop(TestTimeouts::action_max_timeout());
|
||||
ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
|
||||
ASSERT_TRUE(channel->HasAcceptedConnection());
|
||||
channel->ResetToAcceptingConnectionState();
|
||||
ASSERT_FALSE(channel->HasAcceptedConnection());
|
||||
|
||||
base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixTestConnectionProc");
|
||||
ASSERT_TRUE(handle2);
|
||||
base::Process process2 = SpawnChild("IPCChannelPosixTestConnectionProc");
|
||||
ASSERT_TRUE(process2.IsValid());
|
||||
SpinRunLoop(TestTimeouts::action_max_timeout());
|
||||
ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
|
||||
ASSERT_TRUE(channel->HasAcceptedConnection());
|
||||
@ -341,9 +341,9 @@ TEST_F(IPCChannelPosixTest, ResetState) {
|
||||
IPC::Message::PRIORITY_NORMAL);
|
||||
channel->Send(message);
|
||||
SpinRunLoop(TestTimeouts::action_timeout());
|
||||
EXPECT_TRUE(base::KillProcess(handle, 0, false));
|
||||
EXPECT_TRUE(base::KillProcess(process.Handle(), 0, false));
|
||||
int exit_code = 0;
|
||||
EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
|
||||
EXPECT_TRUE(process2.WaitForExit(&exit_code));
|
||||
EXPECT_EQ(0, exit_code);
|
||||
ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
|
||||
ASSERT_FALSE(channel->HasAcceptedConnection());
|
||||
@ -383,16 +383,16 @@ TEST_F(IPCChannelPosixTest, MultiConnection) {
|
||||
ASSERT_TRUE(channel->AcceptsConnections());
|
||||
ASSERT_FALSE(channel->HasAcceptedConnection());
|
||||
|
||||
base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
|
||||
ASSERT_TRUE(handle);
|
||||
base::Process process = SpawnChild("IPCChannelPosixTestConnectionProc");
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
SpinRunLoop(TestTimeouts::action_max_timeout());
|
||||
ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
|
||||
ASSERT_TRUE(channel->HasAcceptedConnection());
|
||||
base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixFailConnectionProc");
|
||||
ASSERT_TRUE(handle2);
|
||||
base::Process process2 = SpawnChild("IPCChannelPosixFailConnectionProc");
|
||||
ASSERT_TRUE(process2.IsValid());
|
||||
SpinRunLoop(TestTimeouts::action_max_timeout());
|
||||
int exit_code = 0;
|
||||
EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
|
||||
EXPECT_TRUE(process2.WaitForExit(&exit_code));
|
||||
EXPECT_EQ(exit_code, 0);
|
||||
ASSERT_EQ(IPCChannelPosixTestListener::DENIED, listener.status());
|
||||
ASSERT_TRUE(channel->HasAcceptedConnection());
|
||||
@ -401,7 +401,7 @@ TEST_F(IPCChannelPosixTest, MultiConnection) {
|
||||
IPC::Message::PRIORITY_NORMAL);
|
||||
channel->Send(message);
|
||||
SpinRunLoop(TestTimeouts::action_timeout());
|
||||
EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
|
||||
EXPECT_TRUE(process.WaitForExit(&exit_code));
|
||||
EXPECT_EQ(exit_code, 0);
|
||||
ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
|
||||
ASSERT_FALSE(channel->HasAcceptedConnection());
|
||||
|
@ -22,8 +22,7 @@ std::string IPCTestBase::GetChannelName(const std::string& test_client_name) {
|
||||
return test_client_name + "__Channel";
|
||||
}
|
||||
|
||||
IPCTestBase::IPCTestBase()
|
||||
: client_process_(base::kNullProcessHandle) {
|
||||
IPCTestBase::IPCTestBase() {
|
||||
}
|
||||
|
||||
IPCTestBase::~IPCTestBase() {
|
||||
@ -104,8 +103,8 @@ std::string IPCTestBase::GetTestMainName() const {
|
||||
}
|
||||
|
||||
bool IPCTestBase::DidStartClient() {
|
||||
DCHECK_NE(base::kNullProcessHandle, client_process_);
|
||||
return client_process_ != base::kNullProcessHandle;
|
||||
DCHECK(client_process_.IsValid());
|
||||
return client_process_.IsValid();
|
||||
}
|
||||
|
||||
#if defined(OS_POSIX)
|
||||
@ -117,7 +116,7 @@ bool IPCTestBase::StartClient() {
|
||||
}
|
||||
|
||||
bool IPCTestBase::StartClientWithFD(int ipcfd) {
|
||||
DCHECK_EQ(client_process_, base::kNullProcessHandle);
|
||||
DCHECK(!client_process_.IsValid());
|
||||
|
||||
base::FileHandleMappingVector fds_to_map;
|
||||
if (ipcfd > -1)
|
||||
@ -133,7 +132,7 @@ bool IPCTestBase::StartClientWithFD(int ipcfd) {
|
||||
#elif defined(OS_WIN)
|
||||
|
||||
bool IPCTestBase::StartClient() {
|
||||
DCHECK_EQ(client_process_, base::kNullProcessHandle);
|
||||
DCHECK(!client_process_.IsValid());
|
||||
client_process_ = SpawnChild(GetTestMainName());
|
||||
return DidStartClient();
|
||||
}
|
||||
@ -141,12 +140,11 @@ bool IPCTestBase::StartClient() {
|
||||
#endif
|
||||
|
||||
bool IPCTestBase::WaitForClientShutdown() {
|
||||
DCHECK(client_process_ != base::kNullProcessHandle);
|
||||
DCHECK(client_process_.IsValid());
|
||||
|
||||
bool rv = base::WaitForSingleProcess(client_process_,
|
||||
bool rv = base::WaitForSingleProcess(client_process_.Handle(),
|
||||
base::TimeDelta::FromSeconds(5));
|
||||
base::CloseProcessHandle(client_process_);
|
||||
client_process_ = base::kNullProcessHandle;
|
||||
client_process_.Close();
|
||||
return rv;
|
||||
}
|
||||
|
||||
|
@ -100,7 +100,7 @@ class IPCTestBase : public base::MultiProcessTest {
|
||||
IPC::Channel* channel() { return channel_.get(); }
|
||||
IPC::ChannelProxy* channel_proxy() { return channel_proxy_.get(); }
|
||||
|
||||
const base::ProcessHandle& client_process() const { return client_process_; }
|
||||
const base::Process& client_process() const { return client_process_; }
|
||||
scoped_refptr<base::TaskRunner> task_runner();
|
||||
|
||||
virtual scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
|
||||
@ -117,7 +117,7 @@ class IPCTestBase : public base::MultiProcessTest {
|
||||
scoped_ptr<IPC::Channel> channel_;
|
||||
scoped_ptr<IPC::ChannelProxy> channel_proxy_;
|
||||
|
||||
base::ProcessHandle client_process_;
|
||||
base::Process client_process_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(IPCTestBase);
|
||||
};
|
||||
|
@ -89,7 +89,7 @@ class IPCChannelMojoTest : public IPCTestBase {
|
||||
bool DidStartClient() override {
|
||||
bool ok = IPCTestBase::DidStartClient();
|
||||
DCHECK(ok);
|
||||
host_->OnClientLaunched(client_process());
|
||||
host_->OnClientLaunched(client_process().Handle());
|
||||
return ok;
|
||||
}
|
||||
|
||||
@ -195,7 +195,7 @@ class IPCChannelMojoErrorTest : public IPCTestBase {
|
||||
bool DidStartClient() override {
|
||||
bool ok = IPCTestBase::DidStartClient();
|
||||
DCHECK(ok);
|
||||
host_->OnClientLaunched(client_process());
|
||||
host_->OnClientLaunched(client_process().Handle());
|
||||
return ok;
|
||||
}
|
||||
|
||||
@ -269,10 +269,11 @@ class IPCChannelMojoDeadHandleTest : public IPCTestBase {
|
||||
|
||||
virtual bool DidStartClient() override {
|
||||
IPCTestBase::DidStartClient();
|
||||
base::ProcessHandle client = client_process();
|
||||
const base::ProcessHandle client = client_process().Handle();
|
||||
// Forces GetFileHandleForProcess() fail. It happens occasionally
|
||||
// in production, so we should exercise it somehow.
|
||||
::CloseHandle(client);
|
||||
// TODO(morrita): figure out how to safely test this.
|
||||
// ::CloseHandle(client);
|
||||
host_->OnClientLaunched(client);
|
||||
return true;
|
||||
}
|
||||
|
@ -55,7 +55,7 @@ TEST_F(IPCMojoBootstrapTest, Connect) {
|
||||
#else
|
||||
ASSERT_TRUE(StartClient());
|
||||
#endif
|
||||
bootstrap->OnClientLaunched(client_process());
|
||||
bootstrap->OnClientLaunched(client_process().Handle());
|
||||
|
||||
base::MessageLoop::current()->Run();
|
||||
|
||||
|
@ -40,7 +40,7 @@ public:
|
||||
bool DidStartClient() override {
|
||||
bool ok = IPCTestBase::DidStartClient();
|
||||
DCHECK(ok);
|
||||
host_->OnClientLaunched(client_process());
|
||||
host_->OnClientLaunched(client_process().Handle());
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
@ -184,7 +184,7 @@ TEST_F(SyncSocketTest, SanityTest) {
|
||||
#if defined(OS_WIN)
|
||||
// On windows we need to duplicate the handle into the server process.
|
||||
BOOL retval = DuplicateHandle(GetCurrentProcess(), pair[1].handle(),
|
||||
client_process(), &target_handle,
|
||||
client_process().Handle(), &target_handle,
|
||||
0, FALSE, DUPLICATE_SAME_ACCESS);
|
||||
EXPECT_TRUE(retval);
|
||||
// Set up a message to pass the handle to the server.
|
||||
|
@ -14,14 +14,13 @@
|
||||
namespace mojo {
|
||||
namespace test {
|
||||
|
||||
MultiprocessTestHelper::MultiprocessTestHelper()
|
||||
: test_child_handle_(base::kNullProcessHandle) {
|
||||
MultiprocessTestHelper::MultiprocessTestHelper() {
|
||||
platform_channel_pair_.reset(new embedder::PlatformChannelPair());
|
||||
server_platform_handle = platform_channel_pair_->PassServerHandle();
|
||||
}
|
||||
|
||||
MultiprocessTestHelper::~MultiprocessTestHelper() {
|
||||
CHECK_EQ(test_child_handle_, base::kNullProcessHandle);
|
||||
CHECK(!test_child_.IsValid());
|
||||
server_platform_handle.reset();
|
||||
platform_channel_pair_.reset();
|
||||
}
|
||||
@ -29,7 +28,7 @@ MultiprocessTestHelper::~MultiprocessTestHelper() {
|
||||
void MultiprocessTestHelper::StartChild(const std::string& test_child_name) {
|
||||
CHECK(platform_channel_pair_);
|
||||
CHECK(!test_child_name.empty());
|
||||
CHECK_EQ(test_child_handle_, base::kNullProcessHandle);
|
||||
CHECK(!test_child_.IsValid());
|
||||
|
||||
std::string test_child_main = test_child_name + "TestChildMain";
|
||||
|
||||
@ -49,21 +48,20 @@ void MultiprocessTestHelper::StartChild(const std::string& test_child_name) {
|
||||
#error "Not supported yet."
|
||||
#endif
|
||||
|
||||
test_child_handle_ =
|
||||
test_child_ =
|
||||
base::SpawnMultiProcessTestChild(test_child_main, command_line, options);
|
||||
platform_channel_pair_->ChildProcessLaunched();
|
||||
|
||||
CHECK_NE(test_child_handle_, base::kNullProcessHandle);
|
||||
CHECK(test_child_.IsValid());
|
||||
}
|
||||
|
||||
int MultiprocessTestHelper::WaitForChildShutdown() {
|
||||
CHECK_NE(test_child_handle_, base::kNullProcessHandle);
|
||||
CHECK(test_child_.IsValid());
|
||||
|
||||
int rv = -1;
|
||||
CHECK(base::WaitForExitCodeWithTimeout(test_child_handle_, &rv,
|
||||
TestTimeouts::action_timeout()));
|
||||
base::CloseProcessHandle(test_child_handle_);
|
||||
test_child_handle_ = base::kNullProcessHandle;
|
||||
CHECK(test_child_.WaitForExitWithTimeout(TestTimeouts::action_timeout(),
|
||||
&rv));
|
||||
test_child_.Close();
|
||||
return rv;
|
||||
}
|
||||
|
||||
|
@ -8,7 +8,7 @@
|
||||
#include <string>
|
||||
|
||||
#include "base/macros.h"
|
||||
#include "base/process/process_handle.h"
|
||||
#include "base/process/process.h"
|
||||
#include "base/test/multiprocess_test.h"
|
||||
#include "base/test/test_timeouts.h"
|
||||
#include "mojo/edk/embedder/scoped_platform_handle.h"
|
||||
@ -58,7 +58,7 @@ class MultiprocessTestHelper {
|
||||
scoped_ptr<embedder::PlatformChannelPair> platform_channel_pair_;
|
||||
|
||||
// Valid after |StartChild()| and before |WaitForChildShutdown()|.
|
||||
base::ProcessHandle test_child_handle_;
|
||||
base::Process test_child_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(MultiprocessTestHelper);
|
||||
};
|
||||
|
@ -100,14 +100,14 @@ class BootstrapSandboxTest : public base::MultiProcessTest {
|
||||
sandbox_->PrepareToForkWithPolicy(policy_id);
|
||||
base::LaunchOptions options;
|
||||
options.replacement_bootstrap_name = sandbox_->server_bootstrap_name();
|
||||
base::ProcessHandle pid = SpawnChildWithOptions(child_name, options);
|
||||
ASSERT_GT(pid, 0);
|
||||
sandbox_->FinishedFork(pid);
|
||||
base::Process process = SpawnChildWithOptions(child_name, options);
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
sandbox_->FinishedFork(process.Handle());
|
||||
int code = 0;
|
||||
EXPECT_TRUE(base::WaitForExitCode(pid, &code));
|
||||
EXPECT_TRUE(process.WaitForExit(&code));
|
||||
EXPECT_EQ(0, code);
|
||||
if (out_pid)
|
||||
*out_pid = pid;
|
||||
*out_pid = process.pid();
|
||||
}
|
||||
|
||||
protected:
|
||||
@ -121,15 +121,15 @@ TEST_F(BootstrapSandboxTest, DistributedNotifications_Unsandboxed) {
|
||||
base::scoped_nsobject<DistributedNotificationObserver> observer(
|
||||
[[DistributedNotificationObserver alloc] init]);
|
||||
|
||||
base::ProcessHandle pid = SpawnChild(kNotificationTestMain);
|
||||
ASSERT_GT(pid, 0);
|
||||
base::Process process = SpawnChild(kNotificationTestMain);
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
int code = 0;
|
||||
EXPECT_TRUE(base::WaitForExitCode(pid, &code));
|
||||
EXPECT_TRUE(process.WaitForExit(&code));
|
||||
EXPECT_EQ(0, code);
|
||||
|
||||
[observer waitForNotification];
|
||||
EXPECT_EQ(1, [observer receivedCount]);
|
||||
EXPECT_EQ(pid, [[observer object] intValue]);
|
||||
EXPECT_EQ(process.pid(), [[observer object] intValue]);
|
||||
}
|
||||
|
||||
// Run the test with the sandbox enabled without notifications on the policy
|
||||
@ -439,10 +439,9 @@ TEST_F(BootstrapSandboxTest, ChildOutliveSandbox) {
|
||||
sandbox_->PrepareToForkWithPolicy(kTestPolicyId);
|
||||
base::LaunchOptions options;
|
||||
options.replacement_bootstrap_name = sandbox_->server_bootstrap_name();
|
||||
base::ProcessHandle pid =
|
||||
SpawnChildWithOptions("ChildOutliveSandbox", options);
|
||||
ASSERT_GT(pid, 0);
|
||||
sandbox_->FinishedFork(pid);
|
||||
base::Process process = SpawnChildWithOptions("ChildOutliveSandbox", options);
|
||||
ASSERT_TRUE(process.IsValid());
|
||||
sandbox_->FinishedFork(process.Handle());
|
||||
|
||||
// Synchronize with the child.
|
||||
mach_msg_empty_rcv_t rcv_msg;
|
||||
@ -468,7 +467,7 @@ TEST_F(BootstrapSandboxTest, ChildOutliveSandbox) {
|
||||
EXPECT_EQ(KERN_SUCCESS, kr) << mach_error_string(kr);
|
||||
|
||||
int code = 0;
|
||||
EXPECT_TRUE(base::WaitForExitCode(pid, &code));
|
||||
EXPECT_TRUE(process.WaitForExit(&code));
|
||||
EXPECT_EQ(0, code);
|
||||
}
|
||||
|
||||
|
@ -149,21 +149,19 @@ XPC_TEST_F(GetSenderPID) // {
|
||||
#pragma GCC diagnostic pop
|
||||
ASSERT_EQ(KERN_SUCCESS, kr);
|
||||
|
||||
base::ProcessHandle child_handle = base::SpawnMultiProcessTestChild(
|
||||
base::Process child = base::SpawnMultiProcessTestChild(
|
||||
"GetSenderPID",
|
||||
base::GetMultiProcessTestChildBaseCommandLine(),
|
||||
base::LaunchOptions());
|
||||
ASSERT_NE(base::kNullProcessHandle, child_handle);
|
||||
ASSERT_TRUE(child.IsValid());
|
||||
|
||||
int exit_code = -1;
|
||||
ASSERT_TRUE(base::WaitForExitCode(child_handle, &exit_code));
|
||||
ASSERT_TRUE(child.WaitForExit(&exit_code));
|
||||
EXPECT_EQ(0, exit_code);
|
||||
|
||||
EXPECT_EQ(base::GetProcId(child_handle), sender_pid);
|
||||
EXPECT_EQ(base::GetProcId(child_handle), child_pid);
|
||||
EXPECT_EQ(child.pid(), sender_pid);
|
||||
EXPECT_EQ(child.pid(), child_pid);
|
||||
EXPECT_EQ(sender_pid, child_pid);
|
||||
|
||||
base::CloseProcessHandle(child_handle);
|
||||
}
|
||||
|
||||
MULTIPROCESS_TEST_MAIN(GetSenderPID) {
|
||||
|
Reference in New Issue
Block a user