blob: 88206d8f82ef044626ebcd5b3c7e78d98da24ca8 [file] [log] [blame]
// Copyright 2018 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/chrome_cleaner/ipc/mojo_chrome_prompt_ipc.h"
#include <memory>
#include <tuple>
#include <utility>
#include <vector>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/test/scoped_task_environment.h"
#include "base/threading/sequenced_task_runner_handle.h"
#include "chrome/chrome_cleaner/ipc/ipc_test_util.h"
#include "chrome/chrome_cleaner/logging/scoped_logging.h"
#include "chrome/chrome_cleaner/test/test_util.h"
#include "components/chrome_cleaner/public/interfaces/chrome_prompt.mojom.h"
#include "components/chrome_cleaner/test/test_name_helper.h"
#include "mojo/public/cpp/bindings/binding.h"
#include "mojo/public/cpp/system/message_pipe.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/multiprocess_func_list.h"
namespace chrome_cleaner {
namespace {
using testing::Bool;
using testing::Values;
constexpr char kIncludeUwESwitch[] = "include-uwe";
constexpr char kIncludeUwSSwitch[] = "include-uws";
constexpr char kIncludeRegistryKeysSwitch[] = "include-registry-keys";
constexpr char kExpectedPromptResultSwitch[] = "expected-prompt-result";
constexpr char kExpectedParentDisconnectedSwitch[] =
"expected-parent-disconnected";
const base::FilePath kBadFilePath(L"/path/to/bad.dll");
const base::string16 kBadRegistryKey(L"HKCU:32\\Software\\ugly-uws\\nasty");
const base::string16 kExtensionId(L"expected-extension-id");
// Possible moments when the parent process can disconnect from the IPC to
// check connection error handling in the child process.
enum class ParentDisconnected {
// The parent process will not try to disconnect while the child process
// is running.
kNone,
// The parent process will disconnect before the child process sends a
// message through the pipe.
kOnStartup,
// The parent process will disconnect after receiving a message from the
// child process and before sending out a response.
kWhileProcessingChildRequest,
// The parent process will disconnect once no further communication is
// required in the child process.
kOnDone,
};
std::ostream& operator<<(std::ostream& stream,
ParentDisconnected parent_disconnected) {
switch (parent_disconnected) {
case ParentDisconnected::kNone:
stream << "NotDisconnected";
break;
case ParentDisconnected::kOnStartup:
stream << "DisconnectedOnStartup";
break;
case ParentDisconnected::kWhileProcessingChildRequest:
stream << "DisconnectedWhileProcessingChildRequest";
break;
case ParentDisconnected::kOnDone:
stream << "DisconnectedOnDone";
break;
}
return stream;
}
struct TestConfig {
bool uws_expected;
bool uwe_expected;
bool with_registry_keys;
mojom::PromptAcceptance expected_prompt_acceptance;
ParentDisconnected expected_parent_disconnected;
};
// Parent process.
class MockChromePrompt : public mojom::ChromePrompt {
public:
MockChromePrompt(TestConfig test_config, mojom::ChromePromptRequest request)
: test_config_(test_config), binding_(this, std::move(request)) {}
~MockChromePrompt() override = default;
void PromptUser(
const std::vector<base::FilePath>& files_to_delete,
const base::Optional<std::vector<base::string16>>& registry_keys,
const base::Optional<std::vector<base::string16>>& extension_ids,
mojom::ChromePrompt::PromptUserCallback callback) override {
EXPECT_NE(test_config_.uws_expected, files_to_delete.empty());
if (test_config_.uws_expected) {
EXPECT_EQ(1UL, files_to_delete.size());
EXPECT_EQ(kBadFilePath, files_to_delete.front());
}
if (test_config_.with_registry_keys) {
EXPECT_EQ(1UL, registry_keys->size());
EXPECT_EQ(kBadRegistryKey, registry_keys->front());
}
CloseConnectionIf(ParentDisconnected::kWhileProcessingChildRequest);
std::move(callback).Run(test_config_.expected_prompt_acceptance);
if (!test_config_.uwe_expected) {
CloseConnectionIf(ParentDisconnected::kOnDone);
}
}
void DisableExtensions(const std::vector<base::string16>& extension_ids,
DisableExtensionsCallback callback) override {
EXPECT_NE(test_config_.uwe_expected, extension_ids.empty());
if (test_config_.uwe_expected) {
EXPECT_EQ(kExtensionId, extension_ids.front());
} else {
EXPECT_EQ(0UL, extension_ids.size());
}
std::move(callback).Run(true);
CloseConnectionIf(ParentDisconnected::kOnDone);
}
// Close the IPC connection on the parent process depending on the value of
// |parent_disconnected|.
void CloseConnectionIf(ParentDisconnected parent_disconnected) {
if (test_config_.expected_parent_disconnected == parent_disconnected)
binding_.Close();
}
TestConfig test_config_;
mojo::Binding<chrome_cleaner::mojom::ChromePrompt> binding_;
};
class ChromePromptIPCParentProcess : public ParentProcess {
public:
ChromePromptIPCParentProcess(TestConfig test_config,
scoped_refptr<MojoTaskRunner> mojo_task_runner)
: ParentProcess(std::move(mojo_task_runner)), test_config_(test_config) {
if (test_config.uws_expected)
AppendSwitch(kIncludeUwSSwitch);
if (test_config.uwe_expected) {
AppendSwitch(kIncludeUwESwitch);
}
if (test_config.with_registry_keys)
AppendSwitch(kIncludeRegistryKeysSwitch);
AppendSwitch(kExpectedPromptResultSwitch,
base::NumberToString(
static_cast<int>(test_config.expected_prompt_acceptance)));
AppendSwitch(kExpectedParentDisconnectedSwitch,
base::NumberToString(static_cast<int>(
test_config.expected_parent_disconnected)));
}
protected:
void CreateImpl(mojo::ScopedMessagePipeHandle mojo_pipe) override {
chrome_cleaner::mojom::ChromePromptRequest chrome_prompt_request(
std::move(mojo_pipe));
mock_chrome_prompt_ = std::make_unique<MockChromePrompt>(
test_config_, std::move(chrome_prompt_request));
// At this point, the child process should be connected.
mock_chrome_prompt_->CloseConnectionIf(ParentDisconnected::kOnStartup);
}
void DestroyImpl() override { mock_chrome_prompt_.reset(); }
private:
~ChromePromptIPCParentProcess() override = default;
TestConfig test_config_;
std::unique_ptr<MockChromePrompt> mock_chrome_prompt_;
};
class ChromePromptIPCTestErrorHandler : public ChromePromptIPC::ErrorHandler {
public:
ChromePromptIPCTestErrorHandler(base::OnceClosure on_closed,
base::OnceClosure on_closed_after_done)
: on_closed_(std::move(on_closed)),
on_closed_after_done_(std::move(on_closed_after_done)) {}
~ChromePromptIPCTestErrorHandler() override = default;
void OnConnectionClosed() override { std::move(on_closed_).Run(); }
void OnConnectionClosedAfterDone() override {
std::move(on_closed_after_done_).Run();
}
base::OnceClosure on_closed_;
base::OnceClosure on_closed_after_done_;
};
// Child process.
class ChromePromptIPCChildProcess : public ChildProcess {
public:
explicit ChromePromptIPCChildProcess(
scoped_refptr<MojoTaskRunner> mojo_task_runner)
: ChildProcess(std::move(mojo_task_runner)) {}
void SendUwEDataToParentProcess(ChromePromptIPC* chrome_prompt_ipc,
base::OnceClosure done) {
CHECK(chrome_prompt_ipc);
std::vector<base::string16> extensions;
if (uwe_expected()) {
extensions.push_back(kExtensionId);
} else {
std::move(done).Run();
return;
}
chrome_prompt_ipc->PostDisableExtensionsTask(
std::move(extensions),
base::BindOnce(
&ChromePromptIPCChildProcess::ReceiveDisableExtensionsResult,
base::Unretained(this), base::Passed(&done)));
}
void SendUwSDataToParentProcess(ChromePromptIPC* chrome_prompt_ipc,
base::OnceClosure done) {
CHECK(chrome_prompt_ipc);
std::vector<base::FilePath> files_to_delete;
std::vector<base::string16> registry_keys;
std::vector<base::string16> extension_ids;
if (uws_expected()) {
files_to_delete.push_back(kBadFilePath);
if (with_registry_keys())
registry_keys.push_back(kBadRegistryKey);
}
chrome_prompt_ipc->PostPromptUserTask(
std::move(files_to_delete), std::move(registry_keys),
std::move(extension_ids),
base::BindOnce(&ChromePromptIPCChildProcess::ReceivePromptResult,
base::Unretained(this), base::Passed(&done)));
}
ParentDisconnected expected_parent_disconnected() const {
int val = -1;
CHECK(base::StringToInt(
command_line().GetSwitchValueASCII(kExpectedParentDisconnectedSwitch),
&val));
return static_cast<ParentDisconnected>(val);
}
private:
~ChromePromptIPCChildProcess() override = default;
void ReceivePromptResult(base::OnceClosure done,
mojom::PromptAcceptance prompt_acceptance) {
CHECK_EQ(expected_prompt_acceptance(), prompt_acceptance);
// Unblocks the main thread.
std::move(done).Run();
}
void ReceiveDisableExtensionsResult(base::OnceClosure done, bool completed) {
CHECK(completed);
std::move(done).Run();
}
bool uws_expected() const {
return command_line().HasSwitch(kIncludeUwSSwitch);
}
bool uwe_expected() const {
return command_line().HasSwitch(kIncludeUwESwitch);
}
bool with_registry_keys() const {
return uws_expected() &&
command_line().HasSwitch(kIncludeRegistryKeysSwitch);
}
mojom::PromptAcceptance expected_prompt_acceptance() const {
int val = -1;
CHECK(base::StringToInt(
command_line().GetSwitchValueASCII(kExpectedPromptResultSwitch), &val));
return static_cast<mojom::PromptAcceptance>(val);
}
};
constexpr int kEarlyDisconnectionExitCode = 100;
constexpr int kSuccessExitCode = 0;
MULTIPROCESS_TEST_MAIN(ChromePromptIPCClientMain) {
static constexpr int kInternalTestFailureExitCode = -1;
base::test::ScopedTaskEnvironment scoped_task_environment;
scoped_refptr<MojoTaskRunner> mojo_task_runner = MojoTaskRunner::Create();
auto child_process =
base::MakeRefCounted<ChromePromptIPCChildProcess>(mojo_task_runner);
base::RunLoop on_done_run_loop;
// The parent process can disconnect while the pipe is required or after it's
// no longer needed. In the former case, the child process will immediately
// exit; in the latter, it will break |on_done_run_loop|, which will be
// blocking its main thread.
ChromePromptIPCTestErrorHandler error_handler(
base::BindOnce([] {
exit(::testing::Test::HasFailure() ? kInternalTestFailureExitCode
: kEarlyDisconnectionExitCode);
}),
on_done_run_loop.QuitClosure());
ChromePromptIPC* chrome_prompt_ipc = new MojoChromePromptIPC(
child_process->mojo_pipe_token(), mojo_task_runner);
chrome_prompt_ipc->Initialize(&error_handler);
if (child_process->expected_parent_disconnected() ==
ParentDisconnected::kOnStartup) {
// If a failure on startup is expected, the child process will wait until
// the pipe gets disconnected (which will terminate the process), or
// eventually timeout if the disconnection is never received.
base::RunLoop().Run();
}
// After the response from the parent process is received, this will post a
// task to unblock the child process's main thread. Not blocking the main
// thread can lead to race condition on exit.
base::RunLoop prompt_user_run_loop;
base::RunLoop extension_run_loop;
child_process->SendUwSDataToParentProcess(chrome_prompt_ipc,
prompt_user_run_loop.QuitClosure());
prompt_user_run_loop.Run();
child_process->SendUwEDataToParentProcess(chrome_prompt_ipc,
extension_run_loop.QuitClosure());
extension_run_loop.Run();
if (child_process->expected_parent_disconnected() ==
ParentDisconnected::kOnDone) {
// Only block the main thread at this point if the parent process is
// expected to disconnect once communication is over.
on_done_run_loop.Run();
}
return ::testing::Test::HasFailure() ? kInternalTestFailureExitCode
: kSuccessExitCode;
}
class ChromePromptIPCTest
: public ::testing::TestWithParam<std::tuple<bool,
bool,
bool,
mojom::PromptAcceptance,
ParentDisconnected>> {
public:
void SetUp() override { mojo_task_runner_ = MojoTaskRunner::Create(); }
scoped_refptr<MojoTaskRunner> mojo_task_runner_;
scoped_refptr<ChromePromptIPCParentProcess> parent_process_;
};
TEST_P(ChromePromptIPCTest, Communication) {
TestConfig test_config;
std::tie(test_config.uws_expected, test_config.uwe_expected,
test_config.with_registry_keys,
test_config.expected_prompt_acceptance,
test_config.expected_parent_disconnected) = GetParam();
if (test_config.with_registry_keys)
ASSERT_TRUE(test_config.uws_expected);
parent_process_ = base::MakeRefCounted<ChromePromptIPCParentProcess>(
test_config, mojo_task_runner_);
int32_t exit_code = -1;
EXPECT_TRUE(parent_process_->LaunchConnectedChildProcess(
"ChromePromptIPCClientMain", &exit_code));
int32_t expected_exit_code =
test_config.expected_parent_disconnected == ParentDisconnected::kNone ||
test_config.expected_parent_disconnected ==
ParentDisconnected::kOnDone
? kSuccessExitCode
: kEarlyDisconnectionExitCode;
EXPECT_EQ(expected_exit_code, exit_code);
}
INSTANTIATE_TEST_SUITE_P(NoUwSPresent,
ChromePromptIPCTest,
testing::Combine(
/*uws_expected=*/Values(false),
/*uwe_expected=*/Values(false),
/*with_registry_keys=*/Values(false),
Values(mojom::PromptAcceptance::DENIED),
Values(ParentDisconnected::kNone,
ParentDisconnected::kOnStartup)),
GetParamNameForTest());
INSTANTIATE_TEST_SUITE_P(
UwSPresent,
ChromePromptIPCTest,
testing::Combine(
/*uws_expected=*/Values(true),
/*uwe_expected=*/Bool(),
/*with_registry_keys=*/Bool(),
Values(mojom::PromptAcceptance::ACCEPTED_WITH_LOGS,
mojom::PromptAcceptance::ACCEPTED_WITHOUT_LOGS,
mojom::PromptAcceptance::DENIED),
Values(ParentDisconnected::kNone,
ParentDisconnected::kOnStartup,
ParentDisconnected::kWhileProcessingChildRequest,
ParentDisconnected::kOnDone)),
GetParamNameForTest());
} // namespace
} // namespace chrome_cleaner