blob: a3817729e1e9fc77eb304518369c531b7ab8f4a9 [file] [log] [blame]
// Copyright 2019 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 "chrome/browser/safe_browsing/chrome_cleaner/reporter_runner_win.h"
#include "base/base_switches.h"
#include "base/command_line.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/process/launch.h"
#include "base/process/process.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/synchronization/waitable_event.h"
#include "base/test/multiprocess_test.h"
#include "base/test/task_environment.h"
#include "base/test/test_timeouts.h"
#include "base/time/time.h"
#include "base/win/win_util.h"
#include "chrome/browser/safe_browsing/chrome_cleaner/sw_reporter_invocation_win.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/multiprocess_func_list.h"
using ::testing::AssertionFailure;
using ::testing::AssertionResult;
using ::testing::AssertionSuccess;
namespace safe_browsing {
namespace {
constexpr char kParentHandleSwitch[] = "parent-handle";
std::string LastSystemErrorString() {
return logging::SystemErrorCodeToString(logging::GetLastSystemErrorCode());
// Duplicates |src_handle| and gives |target_process| access to it.
// To give a process that doesn't exist yet access to the handle, use the
// current process as |target_process| and add the resulting handle to
// LaunchOptions::handles_to_inherit_vector.
HANDLE DuplicateHandleIntoProcess(const base::Process& target_process,
HANDLE src_handle) {
HANDLE target_handle;
if (!::DuplicateHandle(/*src_process=*/::GetCurrentProcess(), src_handle,
target_process.Handle(), &target_handle,
/*desired_access=*/0, /*inherit_handle=*/true,
return target_handle;
// Allows a test child to spawn a test grandchild without endless recursion.
base::CommandLine GetNestedTestChildBaseCommandLine() {
base::CommandLine command_line =
// Since we are already be in a child process, remove the test child process
// switch. It will be re-added with the grandchild test name by
// SpawnMultiprocessTestChild.
return command_line;
// Gives the parent process access to |grandchild|'s process handle. Called in
// the child process.
void GiveGrandchildHandleToParent(const base::Process& grandchild) {
// Get the parent process handle from the commandline.
unsigned int raw_handle;
base::Process parent(base::win::Uint32ToHandle(raw_handle));
// Give the parent access to the grandchild process handle and write it to
// stdout.
base::File write_pipe(::GetStdHandle(STD_OUTPUT_HANDLE));
uint32_t grandchild_handle = base::win::HandleToUint32(
DuplicateHandleIntoProcess(parent, grandchild.Handle()));
constexpr int handle_size = sizeof(grandchild_handle);
reinterpret_cast<char*>(&grandchild_handle), handle_size),
// Reporter delegate that implements LaunchReporterProcess to spawn a
// multiprocess test child.
class LaunchReporterDelegate : public internal::SwReporterTestingDelegate {
LaunchReporterDelegate() = default;
~LaunchReporterDelegate() override = default;
base::Process LaunchReporterProcess(
const SwReporterInvocation& invocation,
const base::LaunchOptions& options) override {
// Launch a multiprocess test child, getting the name from the invocation
// commandline.
base::Process grandchild = base::SpawnMultiProcessTestChild(
GetNestedTestChildBaseCommandLine(), options);
return grandchild;
int WaitForReporterExit(const base::Process& process) const override {
int exit_code;
return exit_code;
base::Time Now() const override {
return base::Time::Now();
base::TaskRunner* BlockingTaskRunner() const override {
return nullptr;
ChromeCleanerController* GetCleanerController() override {
return nullptr;
void CreateChromeCleanerDialogController() override { NOTREACHED(); }
// Spawns a test child process that runs |child_function|. This process must
// spawn a grandchild process and write its handle to stdout.
// On success |child| will be set to the child process object and |grandchild|
// will be set to the grandchild process object. Both of these processes will
// be valid and running.
AssertionResult CreateRunningProcesseses(const std::string& child_function,
base::Process* child,
base::Process* grandchild) {
base::CommandLine child_command_line =
base::LaunchOptions options;
// Give the child a handle to the current process. It will need this to pass
// the grandchild handle back to us.
// ::GetCurrentProcess returns a pseudo-handle that always refers to the
// current process. Duplicate it to get a real handle to pass to the child.
HANDLE pseudo_handle = ::GetCurrentProcess();
HANDLE parent_handle =
DuplicateHandleIntoProcess(base::Process::Current(), pseudo_handle);
if (parent_handle == INVALID_HANDLE_VALUE) {
return AssertionFailure()
<< "Failed to duplicate parent handle: " << LastSystemErrorString();
// Create a pipe to read the grandchild handle back from the child.
// (Adapted from
HANDLE read_handle, write_handle;
if (!::CreatePipe(&read_handle, &write_handle, nullptr, 0)) {
return AssertionFailure()
<< "Failed to create pipe: " << LastSystemErrorString();
base::File read_pipe(read_handle);
base::File write_pipe(write_handle);
options.stdin_handle = INVALID_HANDLE_VALUE;
options.stdout_handle = write_handle;
options.stderr_handle = ::GetStdHandle(STD_ERROR_HANDLE);
*child = base::SpawnMultiProcessTestChild(child_function, child_command_line,
if (!child->IsValid()) {
return AssertionFailure() << "Failed to spawn child process";
// Read the grandchild handle from the child.
uint32_t grandchild_handle;
constexpr int handle_size = sizeof(grandchild_handle);
int bytes_read = read_pipe.ReadAtCurrentPos(
reinterpret_cast<char*>(&grandchild_handle), handle_size);
if (bytes_read != handle_size) {
return AssertionFailure() << "Failure reading grandchild handle. Expected "
<< handle_size << " bytes, read " << bytes_read;
*grandchild = base::Process(base::win::Uint32ToHandle(grandchild_handle));
if (!grandchild->IsValid()) {
return AssertionFailure()
<< "Child wrote invalid grandchild handle: " << grandchild_handle;
// All the subprocesses should now be running. Wait a moment before verifying
// this since if something went wrong it will take a few msec for them exit.
base::WaitableEvent pause;
if (!child->IsRunning()) {
return AssertionFailure() << "Child process died unexpectedly.";
if (!grandchild->IsRunning()) {
return AssertionFailure() << "Grandchild process died before child did.";
return AssertionSuccess();
void WaitUntilSlain() {
base::test::SingleThreadTaskEnvironment task_environment;
base::RunLoop run_loop;
// Main function for the grandchild process in all tests.
MULTIPROCESS_TEST_MAIN(InfiniteSubprocess) {
return 0;
// ValidateDefaultBehaviour test
// The TerminateWhileRunning test assumes that, when a child process exits, the
// test framework doesn't immediately kill its subprocesses. This makes sure
// that assumption continues to be true.
// Main function for the child process.
MULTIPROCESS_TEST_MAIN(DefaultBehaviourChild) {
base::LaunchOptions options;
base::Process grandchild = base::SpawnMultiProcessTestChild(
"InfiniteSubprocess", GetNestedTestChildBaseCommandLine(), options);
return 0;
// Parent process.
TEST(ReporterRunnerLaunchTest, ValidateDefaultBehaviour) {
if (!safe_browsing::internal::ReporterTerminatesOnBrowserExit()) {
// No point testing the default behaviour if we won't run the
// TerminateWhileRunning test.
base::Process child, grandchild;
CreateRunningProcesseses("DefaultBehaviourChild", &child, &grandchild));
ASSERT_TRUE(child.Terminate(/*exit_code=*/0, /*wait=*/true));
// Expect the grandchild process is still running even though the child is
// not. Wait a moment before checking this because it will take a few msec
// for it to exit.
base::WaitableEvent pause;
grandchild.Terminate(/*exit_code=*/0, /*wait=*/false);
// TerminateWhileRunning test
// This makes sure that the software reporter process doesn't outlive its
// parent if the parent is terminated while the reporter is still running.
// Main function for the child process.
LaunchReporterDelegate delegate;
// Stuff the multiprocess test name for the grandchild into a CommandLine
// object by pretending it's a program path.
const SwReporterInvocation invocation(base::CommandLine(
return safe_browsing::internal::LaunchAndWaitForExit(invocation);
// Parent process.
TEST(ReporterRunnerLaunchTest, TerminateWhileRunning) {
if (!safe_browsing::internal::ReporterTerminatesOnBrowserExit()) {
// Skip the test since the code being tested isn't enabled in this
// configuration.
base::Process child, grandchild;
ASSERT_TRUE(CreateRunningProcesseses("SwReporterChild", &child, &grandchild));
ASSERT_TRUE(child.Terminate(/*exit_code=*/0, /*wait=*/true));
// The child process called safe_browsing::internal::LaunchReporter which
// should set things up so that the grandchild is automatically killed when
// the child exits. Wait a moment before checking this because it will take a
// few msec for it to exit.
base::WaitableEvent pause;
} // namespace
} // namespace safe_browsing