123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433 |
- // 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
|