[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / e9a2d4916e28afc6cd91ed0c13fccb4b1fcbb4ea / . / ipc / ipc_channel_proxy_unittest.cc
blob: 57e515b0b927e49273f5dc000ca5d94bde3a95dc [file] [log] [blame]
Avi Drissmanea1be232022-09-14 23:29:06[diff] [blame]1// Copyright 2014 The Chromium Authors
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
Ho Cheungeb021cd2023-05-23 16:20:33[diff] [blame]5#include "base/memory/raw_ptr.h"
Keishi Hattori834fd1c2023-01-19 07:47:03[diff] [blame]6#include "base/memory/raw_ptr_exclusion.h"
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]7#include "build/build_config.h"
8
avi246998d2015-12-22 02:39:04[diff] [blame]9#include <stddef.h>
10#include <stdint.h>
Ho Cheungeb021cd2023-05-23 16:20:33[diff] [blame]11
danakj03de39b2016-04-23 04:21:09[diff] [blame]12#include <memory>
avi246998d2015-12-22 02:39:04[diff] [blame]13
Carlos Caballerodd8bf7b02019-07-30 14:14:15[diff] [blame]14#include "base/message_loop/message_pump_type.h"
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]15#include "base/pickle.h"
fdoray8e32586852016-06-22 19:56:16[diff] [blame]16#include "base/run_loop.h"
Sean Mahere672a662023-01-09 21:42:28[diff] [blame]17#include "base/task/single_thread_task_runner.h"
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]18#include "base/threading/thread.h"
19#include "ipc/ipc_message.h"
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]20#include "ipc/ipc_test_base.h"
dmichael@chromium.org74122042014-04-25 00:07:30[diff] [blame]21#include "ipc/message_filter.h"
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]22
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]23// Get basic type definitions.
24#define IPC_MESSAGE_IMPL
25#include "ipc/ipc_channel_proxy_unittest_messages.h"
26
27// Generate constructors.
28#include "ipc/struct_constructor_macros.h"
29#include "ipc/ipc_channel_proxy_unittest_messages.h"
30
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]31// Generate param traits write methods.
32#include "ipc/param_traits_write_macros.h"
33namespace IPC {
34#include "ipc/ipc_channel_proxy_unittest_messages.h"
35} // namespace IPC
36
37// Generate param traits read methods.
38#include "ipc/param_traits_read_macros.h"
39namespace IPC {
40#include "ipc/ipc_channel_proxy_unittest_messages.h"
41} // namespace IPC
42
43// Generate param traits log methods.
44#include "ipc/param_traits_log_macros.h"
45namespace IPC {
46#include "ipc/ipc_channel_proxy_unittest_messages.h"
47} // namespace IPC
48
49
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]50namespace {
51
Wezd95d48042018-02-26 20:50:47[diff] [blame]52void CreateRunLoopAndRun(base::RunLoop** run_loop_ptr) {
53 base::RunLoop run_loop;
54 *run_loop_ptr = &run_loop;
55 run_loop.Run();
56 *run_loop_ptr = nullptr;
57}
58
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]59class QuitListener : public IPC::Listener {
60 public:
Wezd95d48042018-02-26 20:50:47[diff] [blame]61 QuitListener() = default;
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]62
dchengfe61fca2014-10-22 02:29:52[diff] [blame]63 bool OnMessageReceived(const IPC::Message& message) override {
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]64 IPC_BEGIN_MESSAGE_MAP(QuitListener, message)
65 IPC_MESSAGE_HANDLER(WorkerMsg_Quit, OnQuit)
66 IPC_MESSAGE_HANDLER(TestMsg_BadMessage, OnBadMessage)
67 IPC_END_MESSAGE_MAP()
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]68 return true;
69 }
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]70
dchengfe61fca2014-10-22 02:29:52[diff] [blame]71 void OnBadMessageReceived(const IPC::Message& message) override {
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]72 bad_message_received_ = true;
73 }
74
Wezd95d48042018-02-26 20:50:47[diff] [blame]75 void OnChannelError() override { CHECK(quit_message_received_); }
76
77 void OnQuit() {
78 quit_message_received_ = true;
79 run_loop_->QuitWhenIdle();
80 }
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]81
82 void OnBadMessage(const BadType& bad_type) {
83 // Should never be called since IPC wouldn't be deserialized correctly.
84 CHECK(false);
85 }
86
Wezd95d48042018-02-26 20:50:47[diff] [blame]87 bool bad_message_received_ = false;
88 bool quit_message_received_ = false;
Keishi Hattori834fd1c2023-01-19 07:47:03[diff] [blame]89 // This field is not a raw_ptr<> because it was filtered by the rewriter for:
90 // #constexpr-ctor-field-initializer, #addr-of
91 RAW_PTR_EXCLUSION base::RunLoop* run_loop_ = nullptr;
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]92};
93
94class ChannelReflectorListener : public IPC::Listener {
95 public:
Wezd95d48042018-02-26 20:50:47[diff] [blame]96 ChannelReflectorListener() = default;
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]97
98 void Init(IPC::Channel* channel) {
99 DCHECK(!channel_);
100 channel_ = channel;
101 }
102
dchengfe61fca2014-10-22 02:29:52[diff] [blame]103 bool OnMessageReceived(const IPC::Message& message) override {
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]104 IPC_BEGIN_MESSAGE_MAP(ChannelReflectorListener, message)
105 IPC_MESSAGE_HANDLER(TestMsg_Bounce, OnTestBounce)
106 IPC_MESSAGE_HANDLER(TestMsg_SendBadMessage, OnSendBadMessage)
Noel Gordon93d53af2017-07-06 12:48:08[diff] [blame]107 IPC_MESSAGE_HANDLER(AutomationMsg_Bounce, OnAutomationBounce)
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]108 IPC_MESSAGE_HANDLER(WorkerMsg_Bounce, OnBounce)
109 IPC_MESSAGE_HANDLER(WorkerMsg_Quit, OnQuit)
110 IPC_END_MESSAGE_MAP()
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]111 return true;
112 }
113
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]114 void OnTestBounce() {
115 channel_->Send(new TestMsg_Bounce());
116 }
117
118 void OnSendBadMessage() {
119 channel_->Send(new TestMsg_BadMessage(BadType()));
120 }
121
Noel Gordon93d53af2017-07-06 12:48:08[diff] [blame]122 void OnAutomationBounce() { channel_->Send(new AutomationMsg_Bounce()); }
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]123
124 void OnBounce() {
125 channel_->Send(new WorkerMsg_Bounce());
126 }
127
128 void OnQuit() {
129 channel_->Send(new WorkerMsg_Quit());
Wezd95d48042018-02-26 20:50:47[diff] [blame]130 run_loop_->QuitWhenIdle();
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]131 }
132
Keishi Hattori834fd1c2023-01-19 07:47:03[diff] [blame]133 // This field is not a raw_ptr<> because it was filtered by the rewriter for:
134 // #constexpr-ctor-field-initializer, #addr-of
135 RAW_PTR_EXCLUSION base::RunLoop* run_loop_ = nullptr;
Wezd95d48042018-02-26 20:50:47[diff] [blame]136
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]137 private:
Ho Cheungeb021cd2023-05-23 16:20:33[diff] [blame]138 raw_ptr<IPC::Channel> channel_ = nullptr;
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]139};
140
dmichael@chromium.org74122042014-04-25 00:07:30[diff] [blame]141class MessageCountFilter : public IPC::MessageFilter {
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]142 public:
dmichael@chromium.org21bb77b2014-04-23 23:54:53[diff] [blame]143 enum FilterEvent {
144 NONE,
145 FILTER_ADDED,
146 CHANNEL_CONNECTED,
147 CHANNEL_ERROR,
148 CHANNEL_CLOSING,
149 FILTER_REMOVED
150 };
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]151
Wezd95d48042018-02-26 20:50:47[diff] [blame]152 MessageCountFilter() = default;
tfarina10a5c062015-09-04 18:47:57[diff] [blame]153 MessageCountFilter(uint32_t supported_message_class)
Wezd95d48042018-02-26 20:50:47[diff] [blame]154 : supported_message_class_(supported_message_class),
155 is_global_filter_(false) {}
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]156
rockote0072ebd2016-09-16 23:40:30[diff] [blame]157 void OnFilterAdded(IPC::Channel* channel) override {
158 EXPECT_TRUE(channel);
dmichael@chromium.org21bb77b2014-04-23 23:54:53[diff] [blame]159 EXPECT_EQ(NONE, last_filter_event_);
160 last_filter_event_ = FILTER_ADDED;
161 }
162
dchengfe61fca2014-10-22 02:29:52[diff] [blame]163 void OnChannelConnected(int32_t peer_pid) override {
dmichael@chromium.org21bb77b2014-04-23 23:54:53[diff] [blame]164 EXPECT_EQ(FILTER_ADDED, last_filter_event_);
165 EXPECT_NE(static_cast<int32_t>(base::kNullProcessId), peer_pid);
166 last_filter_event_ = CHANNEL_CONNECTED;
167 }
168
dchengfe61fca2014-10-22 02:29:52[diff] [blame]169 void OnChannelError() override {
dmichael@chromium.org21bb77b2014-04-23 23:54:53[diff] [blame]170 EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
171 last_filter_event_ = CHANNEL_ERROR;
172 }
173
dchengfe61fca2014-10-22 02:29:52[diff] [blame]174 void OnChannelClosing() override {
dmichael@chromium.org21bb77b2014-04-23 23:54:53[diff] [blame]175 // We may or may not have gotten OnChannelError; if not, the last event has
176 // to be OnChannelConnected.
rockot8a96cca42016-10-21 22:47:50[diff] [blame]177 EXPECT_NE(FILTER_REMOVED, last_filter_event_);
dmichael@chromium.org21bb77b2014-04-23 23:54:53[diff] [blame]178 if (last_filter_event_ != CHANNEL_ERROR)
179 EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
180 last_filter_event_ = CHANNEL_CLOSING;
181 }
182
dchengfe61fca2014-10-22 02:29:52[diff] [blame]183 void OnFilterRemoved() override {
rockot8a96cca42016-10-21 22:47:50[diff] [blame]184 // A filter may be removed at any time, even before the channel is connected
185 // (and thus before OnFilterAdded is ever able to dispatch.) The only time
186 // we won't see OnFilterRemoved is immediately after OnFilterAdded, because
187 // OnChannelConnected is always the next event to fire after that.
188 EXPECT_NE(FILTER_ADDED, last_filter_event_);
dmichael@chromium.org21bb77b2014-04-23 23:54:53[diff] [blame]189 last_filter_event_ = FILTER_REMOVED;
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]190 }
191
dchengfe61fca2014-10-22 02:29:52[diff] [blame]192 bool OnMessageReceived(const IPC::Message& message) override {
dmichael@chromium.org21bb77b2014-04-23 23:54:53[diff] [blame]193 // We should always get the OnFilterAdded and OnChannelConnected events
194 // prior to any messages.
195 EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
196
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]197 if (!is_global_filter_) {
198 EXPECT_EQ(supported_message_class_, IPC_MESSAGE_CLASS(message));
199 }
200 ++messages_received_;
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]201
202 if (!message_filtering_enabled_)
203 return false;
204
205 bool handled = true;
206 IPC_BEGIN_MESSAGE_MAP(MessageCountFilter, message)
207 IPC_MESSAGE_HANDLER(TestMsg_BadMessage, OnBadMessage)
208 IPC_MESSAGE_UNHANDLED(handled = false)
209 IPC_END_MESSAGE_MAP()
210 return handled;
211 }
212
213 void OnBadMessage(const BadType& bad_type) {
214 // Should never be called since IPC wouldn't be deserialized correctly.
215 CHECK(false);
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]216 }
217
dchengfe61fca2014-10-22 02:29:52[diff] [blame]218 bool GetSupportedMessageClasses(
tfarina10a5c062015-09-04 18:47:57[diff] [blame]219 std::vector<uint32_t>* supported_message_classes) const override {
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]220 if (is_global_filter_)
221 return false;
222 supported_message_classes->push_back(supported_message_class_);
223 return true;
224 }
225
226 void set_message_filtering_enabled(bool enabled) {
227 message_filtering_enabled_ = enabled;
228 }
229
230 size_t messages_received() const { return messages_received_; }
dmichael@chromium.org21bb77b2014-04-23 23:54:53[diff] [blame]231 FilterEvent last_filter_event() const { return last_filter_event_; }
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]232
233 private:
Chris Watkins2d879af2017-11-30 02:11:59[diff] [blame]234 ~MessageCountFilter() override = default;
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]235
Wezd95d48042018-02-26 20:50:47[diff] [blame]236 size_t messages_received_ = 0;
237 uint32_t supported_message_class_ = 0;
238 bool is_global_filter_ = true;
dmichael@chromium.org21bb77b2014-04-23 23:54:53[diff] [blame]239
Wezd95d48042018-02-26 20:50:47[diff] [blame]240 FilterEvent last_filter_event_ = NONE;
241 bool message_filtering_enabled_ = false;
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]242};
243
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]244class IPCChannelProxyTest : public IPCChannelMojoTestBase {
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]245 public:
Chris Watkins2d879af2017-11-30 02:11:59[diff] [blame]246 IPCChannelProxyTest() = default;
247 ~IPCChannelProxyTest() override = default;
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]248
dcheng1c3d9ac2014-12-23 19:59:59[diff] [blame]249 void SetUp() override {
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]250 IPCChannelMojoTestBase::SetUp();
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]251
252 Init("ChannelProxyClient");
253
Peter Boströmfb60ea02021-04-05 21:06:12[diff] [blame]254 thread_ = std::make_unique<base::Thread>("ChannelProxyTestServerThread");
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]255 base::Thread::Options options;
Carlos Caballerodd8bf7b02019-07-30 14:14:15[diff] [blame]256 options.message_pump_type = base::MessagePumpType::IO;
Olivier Li81862b82021-05-12 15:36:41[diff] [blame]257 thread_->StartWithOptions(std::move(options));
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]258
Peter Boströmfb60ea02021-04-05 21:06:12[diff] [blame]259 listener_ = std::make_unique<QuitListener>();
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]260 channel_proxy_ = IPC::ChannelProxy::Create(
261 TakeHandle().release(), IPC::Channel::MODE_SERVER, listener_.get(),
Sean Maher5b9af51f2022-11-21 15:32:47[diff] [blame]262 thread_->task_runner(),
263 base::SingleThreadTaskRunner::GetCurrentDefault());
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]264 }
265
dcheng1c3d9ac2014-12-23 19:59:59[diff] [blame]266 void TearDown() override {
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]267 channel_proxy_.reset();
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]268 thread_.reset();
269 listener_.reset();
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]270 IPCChannelMojoTestBase::TearDown();
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]271 }
272
273 void SendQuitMessageAndWaitForIdle() {
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]274 sender()->Send(new WorkerMsg_Quit);
Wezd95d48042018-02-26 20:50:47[diff] [blame]275 CreateRunLoopAndRun(&listener_->run_loop_);
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]276 EXPECT_TRUE(WaitForClientShutdown());
277 }
278
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]279 bool DidListenerGetBadMessage() {
280 return listener_->bad_message_received_;
281 }
282
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]283 IPC::ChannelProxy* channel_proxy() { return channel_proxy_.get(); }
284 IPC::Sender* sender() { return channel_proxy_.get(); }
285
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]286 private:
danakj03de39b2016-04-23 04:21:09[diff] [blame]287 std::unique_ptr<base::Thread> thread_;
288 std::unique_ptr<QuitListener> listener_;
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]289 std::unique_ptr<IPC::ChannelProxy> channel_proxy_;
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]290};
291
amistry6de2ee4f2016-05-05 05:12:09[diff] [blame]292TEST_F(IPCChannelProxyTest, MessageClassFilters) {
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]293 // Construct a filter per message class.
Noel Gordon93d53af2017-07-06 12:48:08[diff] [blame]294 std::vector<scoped_refptr<MessageCountFilter>> class_filters;
295 class_filters.push_back(
kylechar96f3eba2017-09-25 20:23:56[diff] [blame]296 base::MakeRefCounted<MessageCountFilter>(TestMsgStart));
Noel Gordon93d53af2017-07-06 12:48:08[diff] [blame]297 class_filters.push_back(
kylechar96f3eba2017-09-25 20:23:56[diff] [blame]298 base::MakeRefCounted<MessageCountFilter>(AutomationMsgStart));
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]299 for (size_t i = 0; i < class_filters.size(); ++i)
300 channel_proxy()->AddFilter(class_filters[i].get());
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]301
302 // Send a message for each class; each filter should receive just one message.
Noel Gordon93d53af2017-07-06 12:48:08[diff] [blame]303 sender()->Send(new TestMsg_Bounce);
304 sender()->Send(new AutomationMsg_Bounce);
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]305
306 // Send some messages not assigned to a specific or valid message class.
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]307 sender()->Send(new WorkerMsg_Bounce);
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]308
309 // Each filter should have received just the one sent message of the
310 // corresponding class.
311 SendQuitMessageAndWaitForIdle();
312 for (size_t i = 0; i < class_filters.size(); ++i)
313 EXPECT_EQ(1U, class_filters[i]->messages_received());
314}
315
amistry6de2ee4f2016-05-05 05:12:09[diff] [blame]316TEST_F(IPCChannelProxyTest, GlobalAndMessageClassFilters) {
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]317 // Add a class and global filter.
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]318 scoped_refptr<MessageCountFilter> class_filter(
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]319 new MessageCountFilter(TestMsgStart));
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]320 class_filter->set_message_filtering_enabled(false);
321 channel_proxy()->AddFilter(class_filter.get());
322
323 scoped_refptr<MessageCountFilter> global_filter(new MessageCountFilter());
324 global_filter->set_message_filtering_enabled(false);
325 channel_proxy()->AddFilter(global_filter.get());
326
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]327 // A message of class Test should be seen by both the global filter and
328 // Test-specific filter.
329 sender()->Send(new TestMsg_Bounce);
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]330
331 // A message of a different class should be seen only by the global filter.
Noel Gordon93d53af2017-07-06 12:48:08[diff] [blame]332 sender()->Send(new AutomationMsg_Bounce);
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]333
334 // Flush all messages.
335 SendQuitMessageAndWaitForIdle();
336
337 // The class filter should have received only the class-specific message.
338 EXPECT_EQ(1U, class_filter->messages_received());
339
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]340 // The global filter should have received both messages, as well as the final
341 // QUIT message.
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]342 EXPECT_EQ(3U, global_filter->messages_received());
343}
344
amistry6de2ee4f2016-05-05 05:12:09[diff] [blame]345TEST_F(IPCChannelProxyTest, FilterRemoval) {
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]346 // Add a class and global filter.
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]347 scoped_refptr<MessageCountFilter> class_filter(
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]348 new MessageCountFilter(TestMsgStart));
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]349 scoped_refptr<MessageCountFilter> global_filter(new MessageCountFilter());
350
351 // Add and remove both types of filters.
352 channel_proxy()->AddFilter(class_filter.get());
353 channel_proxy()->AddFilter(global_filter.get());
354 channel_proxy()->RemoveFilter(global_filter.get());
355 channel_proxy()->RemoveFilter(class_filter.get());
356
357 // Send some messages; they should not be seen by either filter.
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]358 sender()->Send(new TestMsg_Bounce);
Noel Gordon93d53af2017-07-06 12:48:08[diff] [blame]359 sender()->Send(new AutomationMsg_Bounce);
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]360
361 // Ensure that the filters were removed and did not receive any messages.
362 SendQuitMessageAndWaitForIdle();
dmichael@chromium.org21bb77b2014-04-23 23:54:53[diff] [blame]363 EXPECT_EQ(MessageCountFilter::FILTER_REMOVED,
364 global_filter->last_filter_event());
365 EXPECT_EQ(MessageCountFilter::FILTER_REMOVED,
366 class_filter->last_filter_event());
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]367 EXPECT_EQ(0U, class_filter->messages_received());
368 EXPECT_EQ(0U, global_filter->messages_received());
369}
370
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]371TEST_F(IPCChannelProxyTest, BadMessageOnListenerThread) {
372 scoped_refptr<MessageCountFilter> class_filter(
373 new MessageCountFilter(TestMsgStart));
374 class_filter->set_message_filtering_enabled(false);
375 channel_proxy()->AddFilter(class_filter.get());
376
377 sender()->Send(new TestMsg_SendBadMessage());
378
379 SendQuitMessageAndWaitForIdle();
380 EXPECT_TRUE(DidListenerGetBadMessage());
381}
382
383TEST_F(IPCChannelProxyTest, BadMessageOnIPCThread) {
384 scoped_refptr<MessageCountFilter> class_filter(
385 new MessageCountFilter(TestMsgStart));
386 class_filter->set_message_filtering_enabled(true);
387 channel_proxy()->AddFilter(class_filter.get());
388
389 sender()->Send(new TestMsg_SendBadMessage());
390
391 SendQuitMessageAndWaitForIdle();
392 EXPECT_TRUE(DidListenerGetBadMessage());
393}
394
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]395class IPCChannelBadMessageTest : public IPCChannelMojoTestBase {
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]396 public:
Daniel Cheng3e6beaa72014-12-31 03:48:36[diff] [blame]397 void SetUp() override {
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]398 IPCChannelMojoTestBase::SetUp();
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]399
400 Init("ChannelProxyClient");
401
Peter Boströmfb60ea02021-04-05 21:06:12[diff] [blame]402 listener_ = std::make_unique<QuitListener>();
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]403 CreateChannel(listener_.get());
404 ASSERT_TRUE(ConnectChannel());
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]405 }
406
Daniel Cheng3e6beaa72014-12-31 03:48:36[diff] [blame]407 void TearDown() override {
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]408 IPCChannelMojoTestBase::TearDown();
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]409 listener_.reset();
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]410 }
411
412 void SendQuitMessageAndWaitForIdle() {
413 sender()->Send(new WorkerMsg_Quit);
Wezd95d48042018-02-26 20:50:47[diff] [blame]414 CreateRunLoopAndRun(&listener_->run_loop_);
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]415 EXPECT_TRUE(WaitForClientShutdown());
416 }
417
418 bool DidListenerGetBadMessage() {
419 return listener_->bad_message_received_;
420 }
421
422 private:
danakj03de39b2016-04-23 04:21:09[diff] [blame]423 std::unique_ptr<QuitListener> listener_;
jam@chromium.org8e9ba762014-05-21 16:39:18[diff] [blame]424};
425
426TEST_F(IPCChannelBadMessageTest, BadMessage) {
427 sender()->Send(new TestMsg_SendBadMessage());
428 SendQuitMessageAndWaitForIdle();
429 EXPECT_TRUE(DidListenerGetBadMessage());
430}
431
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]432DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(ChannelProxyClient) {
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]433 ChannelReflectorListener listener;
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]434 Connect(&listener);
435 listener.Init(channel());
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]436
Wezd95d48042018-02-26 20:50:47[diff] [blame]437 CreateRunLoopAndRun(&listener.run_loop_);
438
sammc4bcc4ed62016-10-27 10:13:59[diff] [blame]439 Close();
jdduke@chromium.orgb51352a2014-02-26 05:18:04[diff] [blame]440}
441
442} // namespace