blob: 78b2b9f420ed09d851d1a722a2bc543740f666e8 [file] [log] [blame] [edit]
// Copyright 2014 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 "build/build_config.h"
#include <stddef.h>
#include <stdint.h>
#include <memory>
#include "base/message_loop/message_pump_type.h"
#include "base/pickle.h"
#include "base/run_loop.h"
#include "base/threading/thread.h"
#include "ipc/ipc_message.h"
#include "ipc/ipc_test_base.h"
#include "ipc/message_filter.h"
// Get basic type definitions.
#define IPC_MESSAGE_IMPL
#include "ipc/ipc_channel_proxy_unittest_messages.h"
// Generate constructors.
#include "ipc/struct_constructor_macros.h"
#include "ipc/ipc_channel_proxy_unittest_messages.h"
// Generate param traits write methods.
#include "ipc/param_traits_write_macros.h"
namespace IPC {
#include "ipc/ipc_channel_proxy_unittest_messages.h"
} // namespace IPC
// Generate param traits read methods.
#include "ipc/param_traits_read_macros.h"
namespace IPC {
#include "ipc/ipc_channel_proxy_unittest_messages.h"
} // namespace IPC
// Generate param traits log methods.
#include "ipc/param_traits_log_macros.h"
namespace IPC {
#include "ipc/ipc_channel_proxy_unittest_messages.h"
} // namespace IPC
namespace {
void CreateRunLoopAndRun(base::RunLoop** run_loop_ptr) {
base::RunLoop run_loop;
*run_loop_ptr = &run_loop;
run_loop.Run();
*run_loop_ptr = nullptr;
}
class QuitListener : public IPC::Listener {
public:
QuitListener() = default;
bool OnMessageReceived(const IPC::Message& message) override {
IPC_BEGIN_MESSAGE_MAP(QuitListener, message)
IPC_MESSAGE_HANDLER(WorkerMsg_Quit, OnQuit)
IPC_MESSAGE_HANDLER(TestMsg_BadMessage, OnBadMessage)
IPC_END_MESSAGE_MAP()
return true;
}
void OnBadMessageReceived(const IPC::Message& message) override {
bad_message_received_ = true;
}
void OnChannelError() override { CHECK(quit_message_received_); }
void OnQuit() {
quit_message_received_ = true;
run_loop_->QuitWhenIdle();
}
void OnBadMessage(const BadType& bad_type) {
// Should never be called since IPC wouldn't be deserialized correctly.
CHECK(false);
}
bool bad_message_received_ = false;
bool quit_message_received_ = false;
base::RunLoop* run_loop_ = nullptr;
};
class ChannelReflectorListener : public IPC::Listener {
public:
ChannelReflectorListener() = default;
void Init(IPC::Channel* channel) {
DCHECK(!channel_);
channel_ = channel;
}
bool OnMessageReceived(const IPC::Message& message) override {
IPC_BEGIN_MESSAGE_MAP(ChannelReflectorListener, message)
IPC_MESSAGE_HANDLER(TestMsg_Bounce, OnTestBounce)
IPC_MESSAGE_HANDLER(TestMsg_SendBadMessage, OnSendBadMessage)
IPC_MESSAGE_HANDLER(AutomationMsg_Bounce, OnAutomationBounce)
IPC_MESSAGE_HANDLER(WorkerMsg_Bounce, OnBounce)
IPC_MESSAGE_HANDLER(WorkerMsg_Quit, OnQuit)
IPC_END_MESSAGE_MAP()
return true;
}
void OnTestBounce() {
channel_->Send(new TestMsg_Bounce());
}
void OnSendBadMessage() {
channel_->Send(new TestMsg_BadMessage(BadType()));
}
void OnAutomationBounce() { channel_->Send(new AutomationMsg_Bounce()); }
void OnBounce() {
channel_->Send(new WorkerMsg_Bounce());
}
void OnQuit() {
channel_->Send(new WorkerMsg_Quit());
run_loop_->QuitWhenIdle();
}
base::RunLoop* run_loop_ = nullptr;
private:
IPC::Channel* channel_ = nullptr;
};
class MessageCountFilter : public IPC::MessageFilter {
public:
enum FilterEvent {
NONE,
FILTER_ADDED,
CHANNEL_CONNECTED,
CHANNEL_ERROR,
CHANNEL_CLOSING,
FILTER_REMOVED
};
MessageCountFilter() = default;
MessageCountFilter(uint32_t supported_message_class)
: supported_message_class_(supported_message_class),
is_global_filter_(false) {}
void OnFilterAdded(IPC::Channel* channel) override {
EXPECT_TRUE(channel);
EXPECT_EQ(NONE, last_filter_event_);
last_filter_event_ = FILTER_ADDED;
}
void OnChannelConnected(int32_t peer_pid) override {
EXPECT_EQ(FILTER_ADDED, last_filter_event_);
EXPECT_NE(static_cast<int32_t>(base::kNullProcessId), peer_pid);
last_filter_event_ = CHANNEL_CONNECTED;
}
void OnChannelError() override {
EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
last_filter_event_ = CHANNEL_ERROR;
}
void OnChannelClosing() override {
// We may or may not have gotten OnChannelError; if not, the last event has
// to be OnChannelConnected.
EXPECT_NE(FILTER_REMOVED, last_filter_event_);
if (last_filter_event_ != CHANNEL_ERROR)
EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
last_filter_event_ = CHANNEL_CLOSING;
}
void OnFilterRemoved() override {
// A filter may be removed at any time, even before the channel is connected
// (and thus before OnFilterAdded is ever able to dispatch.) The only time
// we won't see OnFilterRemoved is immediately after OnFilterAdded, because
// OnChannelConnected is always the next event to fire after that.
EXPECT_NE(FILTER_ADDED, last_filter_event_);
last_filter_event_ = FILTER_REMOVED;
}
bool OnMessageReceived(const IPC::Message& message) override {
// We should always get the OnFilterAdded and OnChannelConnected events
// prior to any messages.
EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
if (!is_global_filter_) {
EXPECT_EQ(supported_message_class_, IPC_MESSAGE_CLASS(message));
}
++messages_received_;
if (!message_filtering_enabled_)
return false;
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(MessageCountFilter, message)
IPC_MESSAGE_HANDLER(TestMsg_BadMessage, OnBadMessage)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
void OnBadMessage(const BadType& bad_type) {
// Should never be called since IPC wouldn't be deserialized correctly.
CHECK(false);
}
bool GetSupportedMessageClasses(
std::vector<uint32_t>* supported_message_classes) const override {
if (is_global_filter_)
return false;
supported_message_classes->push_back(supported_message_class_);
return true;
}
void set_message_filtering_enabled(bool enabled) {
message_filtering_enabled_ = enabled;
}
size_t messages_received() const { return messages_received_; }
FilterEvent last_filter_event() const { return last_filter_event_; }
private:
~MessageCountFilter() override = default;
size_t messages_received_ = 0;
uint32_t supported_message_class_ = 0;
bool is_global_filter_ = true;
FilterEvent last_filter_event_ = NONE;
bool message_filtering_enabled_ = false;
};
class IPCChannelProxyTest : public IPCChannelMojoTestBase {
public:
IPCChannelProxyTest() = default;
~IPCChannelProxyTest() override = default;
void SetUp() override {
IPCChannelMojoTestBase::SetUp();
Init("ChannelProxyClient");
thread_ = std::make_unique<base::Thread>("ChannelProxyTestServerThread");
base::Thread::Options options;
options.message_pump_type = base::MessagePumpType::IO;
thread_->StartWithOptions(std::move(options));
listener_ = std::make_unique<QuitListener>();
channel_proxy_ = IPC::ChannelProxy::Create(
TakeHandle().release(), IPC::Channel::MODE_SERVER, listener_.get(),
thread_->task_runner(), base::ThreadTaskRunnerHandle::Get());
}
void TearDown() override {
channel_proxy_.reset();
thread_.reset();
listener_.reset();
IPCChannelMojoTestBase::TearDown();
}
void SendQuitMessageAndWaitForIdle() {
sender()->Send(new WorkerMsg_Quit);
CreateRunLoopAndRun(&listener_->run_loop_);
EXPECT_TRUE(WaitForClientShutdown());
}
bool DidListenerGetBadMessage() {
return listener_->bad_message_received_;
}
IPC::ChannelProxy* channel_proxy() { return channel_proxy_.get(); }
IPC::Sender* sender() { return channel_proxy_.get(); }
private:
std::unique_ptr<base::Thread> thread_;
std::unique_ptr<QuitListener> listener_;
std::unique_ptr<IPC::ChannelProxy> channel_proxy_;
};
TEST_F(IPCChannelProxyTest, MessageClassFilters) {
// Construct a filter per message class.
std::vector<scoped_refptr<MessageCountFilter>> class_filters;
class_filters.push_back(
base::MakeRefCounted<MessageCountFilter>(TestMsgStart));
class_filters.push_back(
base::MakeRefCounted<MessageCountFilter>(AutomationMsgStart));
for (size_t i = 0; i < class_filters.size(); ++i)
channel_proxy()->AddFilter(class_filters[i].get());
// Send a message for each class; each filter should receive just one message.
sender()->Send(new TestMsg_Bounce);
sender()->Send(new AutomationMsg_Bounce);
// Send some messages not assigned to a specific or valid message class.
sender()->Send(new WorkerMsg_Bounce);
// Each filter should have received just the one sent message of the
// corresponding class.
SendQuitMessageAndWaitForIdle();
for (size_t i = 0; i < class_filters.size(); ++i)
EXPECT_EQ(1U, class_filters[i]->messages_received());
}
TEST_F(IPCChannelProxyTest, GlobalAndMessageClassFilters) {
// Add a class and global filter.
scoped_refptr<MessageCountFilter> class_filter(
new MessageCountFilter(TestMsgStart));
class_filter->set_message_filtering_enabled(false);
channel_proxy()->AddFilter(class_filter.get());
scoped_refptr<MessageCountFilter> global_filter(new MessageCountFilter());
global_filter->set_message_filtering_enabled(false);
channel_proxy()->AddFilter(global_filter.get());
// A message of class Test should be seen by both the global filter and
// Test-specific filter.
sender()->Send(new TestMsg_Bounce);
// A message of a different class should be seen only by the global filter.
sender()->Send(new AutomationMsg_Bounce);
// Flush all messages.
SendQuitMessageAndWaitForIdle();
// The class filter should have received only the class-specific message.
EXPECT_EQ(1U, class_filter->messages_received());
// The global filter should have received both messages, as well as the final
// QUIT message.
EXPECT_EQ(3U, global_filter->messages_received());
}
TEST_F(IPCChannelProxyTest, FilterRemoval) {
// Add a class and global filter.
scoped_refptr<MessageCountFilter> class_filter(
new MessageCountFilter(TestMsgStart));
scoped_refptr<MessageCountFilter> global_filter(new MessageCountFilter());
// Add and remove both types of filters.
channel_proxy()->AddFilter(class_filter.get());
channel_proxy()->AddFilter(global_filter.get());
channel_proxy()->RemoveFilter(global_filter.get());
channel_proxy()->RemoveFilter(class_filter.get());
// Send some messages; they should not be seen by either filter.
sender()->Send(new TestMsg_Bounce);
sender()->Send(new AutomationMsg_Bounce);
// Ensure that the filters were removed and did not receive any messages.
SendQuitMessageAndWaitForIdle();
EXPECT_EQ(MessageCountFilter::FILTER_REMOVED,
global_filter->last_filter_event());
EXPECT_EQ(MessageCountFilter::FILTER_REMOVED,
class_filter->last_filter_event());
EXPECT_EQ(0U, class_filter->messages_received());
EXPECT_EQ(0U, global_filter->messages_received());
}
TEST_F(IPCChannelProxyTest, BadMessageOnListenerThread) {
scoped_refptr<MessageCountFilter> class_filter(
new MessageCountFilter(TestMsgStart));
class_filter->set_message_filtering_enabled(false);
channel_proxy()->AddFilter(class_filter.get());
sender()->Send(new TestMsg_SendBadMessage());
SendQuitMessageAndWaitForIdle();
EXPECT_TRUE(DidListenerGetBadMessage());
}
TEST_F(IPCChannelProxyTest, BadMessageOnIPCThread) {
scoped_refptr<MessageCountFilter> class_filter(
new MessageCountFilter(TestMsgStart));
class_filter->set_message_filtering_enabled(true);
channel_proxy()->AddFilter(class_filter.get());
sender()->Send(new TestMsg_SendBadMessage());
SendQuitMessageAndWaitForIdle();
EXPECT_TRUE(DidListenerGetBadMessage());
}
class IPCChannelBadMessageTest : public IPCChannelMojoTestBase {
public:
void SetUp() override {
IPCChannelMojoTestBase::SetUp();
Init("ChannelProxyClient");
listener_ = std::make_unique<QuitListener>();
CreateChannel(listener_.get());
ASSERT_TRUE(ConnectChannel());
}
void TearDown() override {
IPCChannelMojoTestBase::TearDown();
listener_.reset();
}
void SendQuitMessageAndWaitForIdle() {
sender()->Send(new WorkerMsg_Quit);
CreateRunLoopAndRun(&listener_->run_loop_);
EXPECT_TRUE(WaitForClientShutdown());
}
bool DidListenerGetBadMessage() {
return listener_->bad_message_received_;
}
private:
std::unique_ptr<QuitListener> listener_;
};
TEST_F(IPCChannelBadMessageTest, BadMessage) {
sender()->Send(new TestMsg_SendBadMessage());
SendQuitMessageAndWaitForIdle();
EXPECT_TRUE(DidListenerGetBadMessage());
}
DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(ChannelProxyClient) {
ChannelReflectorListener listener;
Connect(&listener);
listener.Init(channel());
CreateRunLoopAndRun(&listener.run_loop_);
Close();
}
} // namespace