ipc/ipc_channel_proxy_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "build/build_config.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/pickle.h"
   9 #include "base/threading/thread.h"
  10 #include "ipc/ipc_message.h"
  11 #include "ipc/ipc_test_base.h"
  12 #include "ipc/message_filter.h"
  13
  14 // Get basic type definitions.
  15 #define IPC_MESSAGE_IMPL
  16 #include "ipc/ipc_channel_proxy_unittest_messages.h"
  17
  18 // Generate constructors.
  19 #include "ipc/struct_constructor_macros.h"
  20 #include "ipc/ipc_channel_proxy_unittest_messages.h"
  21
  22 // Generate destructors.
  23 #include "ipc/struct_destructor_macros.h"
  24 #include "ipc/ipc_channel_proxy_unittest_messages.h"
  25
  26 // Generate param traits write methods.
  27 #include "ipc/param_traits_write_macros.h"
  28 namespace IPC {
  29 #include "ipc/ipc_channel_proxy_unittest_messages.h"
  30 }  // namespace IPC
  31
  32 // Generate param traits read methods.
  33 #include "ipc/param_traits_read_macros.h"
  34 namespace IPC {
  35 #include "ipc/ipc_channel_proxy_unittest_messages.h"
  36 }  // namespace IPC
  37
  38 // Generate param traits log methods.
  39 #include "ipc/param_traits_log_macros.h"
  40 namespace IPC {
  41 #include "ipc/ipc_channel_proxy_unittest_messages.h"
  42 }  // namespace IPC
  43
  44
  45 namespace {
  46
  47 class QuitListener : public IPC::Listener {
  48  public:
  49   QuitListener() : bad_message_received_(false) {}
  50   virtual ~QuitListener() {}
  51
  52   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
  53     IPC_BEGIN_MESSAGE_MAP(QuitListener, message)
  54       IPC_MESSAGE_HANDLER(WorkerMsg_Quit, OnQuit)
  55       IPC_MESSAGE_HANDLER(TestMsg_BadMessage, OnBadMessage)
  56     IPC_END_MESSAGE_MAP()
  57     return true;
  58   }
  59
  60   virtual void OnBadMessageReceived(const IPC::Message& message) OVERRIDE {
  61     bad_message_received_ = true;
  62   }
  63
  64   void OnQuit() {
  65     base::MessageLoop::current()->QuitWhenIdle();
  66   }
  67
  68   void OnBadMessage(const BadType& bad_type) {
  69     // Should never be called since IPC wouldn't be deserialized correctly.
  70     CHECK(false);
  71   }
  72
  73   bool bad_message_received_;
  74 };
  75
  76 class ChannelReflectorListener : public IPC::Listener {
  77  public:
  78   ChannelReflectorListener() : channel_(NULL) {}
  79   virtual ~ChannelReflectorListener() {}
  80
  81   void Init(IPC::Channel* channel) {
  82     DCHECK(!channel_);
  83     channel_ = channel;
  84   }
  85
  86   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
  87     IPC_BEGIN_MESSAGE_MAP(ChannelReflectorListener, message)
  88       IPC_MESSAGE_HANDLER(TestMsg_Bounce, OnTestBounce)
  89       IPC_MESSAGE_HANDLER(TestMsg_SendBadMessage, OnSendBadMessage)
  90       IPC_MESSAGE_HANDLER(UtilityMsg_Bounce, OnUtilityBounce)
  91       IPC_MESSAGE_HANDLER(WorkerMsg_Bounce, OnBounce)
  92       IPC_MESSAGE_HANDLER(WorkerMsg_Quit, OnQuit)
  93     IPC_END_MESSAGE_MAP()
  94     return true;
  95   }
  96
  97   void OnTestBounce() {
  98     channel_->Send(new TestMsg_Bounce());
  99   }
 100
 101   void OnSendBadMessage() {
 102     channel_->Send(new TestMsg_BadMessage(BadType()));
 103   }
 104
 105   void OnUtilityBounce() {
 106     channel_->Send(new UtilityMsg_Bounce());
 107   }
 108
 109   void OnBounce() {
 110     channel_->Send(new WorkerMsg_Bounce());
 111   }
 112
 113   void OnQuit() {
 114     channel_->Send(new WorkerMsg_Quit());
 115     base::MessageLoop::current()->QuitWhenIdle();
 116   }
 117
 118  private:
 119   IPC::Channel* channel_;
 120 };
 121
 122 class MessageCountFilter : public IPC::MessageFilter {
 123  public:
 124   enum FilterEvent {
 125     NONE,
 126     FILTER_ADDED,
 127     CHANNEL_CONNECTED,
 128     CHANNEL_ERROR,
 129     CHANNEL_CLOSING,
 130     FILTER_REMOVED
 131   };
 132   MessageCountFilter()
 133       : messages_received_(0),
 134         supported_message_class_(0),
 135         is_global_filter_(true),
 136         last_filter_event_(NONE),
 137         message_filtering_enabled_(false) {}
 138
 139   MessageCountFilter(uint32 supported_message_class)
 140       : messages_received_(0),
 141         supported_message_class_(supported_message_class),
 142         is_global_filter_(false),
 143         last_filter_event_(NONE),
 144         message_filtering_enabled_(false) {}
 145
 146   virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE {
 147     EXPECT_TRUE(channel);
 148     EXPECT_EQ(NONE, last_filter_event_);
 149     last_filter_event_ = FILTER_ADDED;
 150   }
 151
 152   virtual void OnChannelConnected(int32_t peer_pid) OVERRIDE {
 153     EXPECT_EQ(FILTER_ADDED, last_filter_event_);
 154     EXPECT_NE(static_cast<int32_t>(base::kNullProcessId), peer_pid);
 155     last_filter_event_ = CHANNEL_CONNECTED;
 156   }
 157
 158   virtual void OnChannelError() OVERRIDE {
 159     EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
 160     last_filter_event_ = CHANNEL_ERROR;
 161   }
 162
 163   virtual void OnChannelClosing() OVERRIDE {
 164     // We may or may not have gotten OnChannelError; if not, the last event has
 165     // to be OnChannelConnected.
 166     if (last_filter_event_ != CHANNEL_ERROR)
 167       EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
 168     last_filter_event_ = CHANNEL_CLOSING;
 169   }
 170
 171   virtual void OnFilterRemoved() OVERRIDE {
 172     // If the channel didn't get a chance to connect, we might see the
 173     // OnFilterRemoved event with no other events preceding it. We still want
 174     // OnFilterRemoved to be called to allow for deleting the Filter.
 175     if (last_filter_event_ != NONE)
 176       EXPECT_EQ(CHANNEL_CLOSING, last_filter_event_);
 177     last_filter_event_ = FILTER_REMOVED;
 178   }
 179
 180   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
 181     // We should always get the OnFilterAdded and OnChannelConnected events
 182     // prior to any messages.
 183     EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
 184
 185     if (!is_global_filter_) {
 186       EXPECT_EQ(supported_message_class_, IPC_MESSAGE_CLASS(message));
 187     }
 188     ++messages_received_;
 189
 190     if (!message_filtering_enabled_)
 191       return false;
 192
 193     bool handled = true;
 194     IPC_BEGIN_MESSAGE_MAP(MessageCountFilter, message)
 195       IPC_MESSAGE_HANDLER(TestMsg_BadMessage, OnBadMessage)
 196       IPC_MESSAGE_UNHANDLED(handled = false)
 197     IPC_END_MESSAGE_MAP()
 198     return handled;
 199   }
 200
 201   void OnBadMessage(const BadType& bad_type) {
 202     // Should never be called since IPC wouldn't be deserialized correctly.
 203     CHECK(false);
 204   }
 205
 206   virtual bool GetSupportedMessageClasses(
 207       std::vector<uint32>* supported_message_classes) const OVERRIDE {
 208     if (is_global_filter_)
 209       return false;
 210     supported_message_classes->push_back(supported_message_class_);
 211     return true;
 212   }
 213
 214   void set_message_filtering_enabled(bool enabled) {
 215     message_filtering_enabled_ = enabled;
 216   }
 217
 218   size_t messages_received() const { return messages_received_; }
 219   FilterEvent last_filter_event() const { return last_filter_event_; }
 220
 221  private:
 222   virtual ~MessageCountFilter() {}
 223
 224   size_t messages_received_;
 225   uint32 supported_message_class_;
 226   bool is_global_filter_;
 227
 228   FilterEvent last_filter_event_;
 229   bool message_filtering_enabled_;
 230 };
 231
 232 class IPCChannelProxyTest : public IPCTestBase {
 233  public:
 234   IPCChannelProxyTest() {}
 235   virtual ~IPCChannelProxyTest() {}
 236
 237   virtual void SetUp() OVERRIDE {
 238     IPCTestBase::SetUp();
 239
 240     Init("ChannelProxyClient");
 241
 242     thread_.reset(new base::Thread("ChannelProxyTestServerThread"));
 243     base::Thread::Options options;
 244     options.message_loop_type = base::MessageLoop::TYPE_IO;
 245     thread_->StartWithOptions(options);
 246
 247     listener_.reset(new QuitListener());
 248     CreateChannelProxy(listener_.get(), thread_->message_loop_proxy().get());
 249
 250     ASSERT_TRUE(StartClient());
 251   }
 252
 253   virtual void TearDown() {
 254     DestroyChannelProxy();
 255     thread_.reset();
 256     listener_.reset();
 257     IPCTestBase::TearDown();
 258   }
 259
 260   void SendQuitMessageAndWaitForIdle() {
 261     sender()->Send(new WorkerMsg_Quit);
 262     base::MessageLoop::current()->Run();
 263     EXPECT_TRUE(WaitForClientShutdown());
 264   }
 265
 266   bool DidListenerGetBadMessage() {
 267     return listener_->bad_message_received_;
 268   }
 269
 270  private:
 271   scoped_ptr<base::Thread> thread_;
 272   scoped_ptr<QuitListener> listener_;
 273 };
 274
 275 TEST_F(IPCChannelProxyTest, MessageClassFilters) {
 276   // Construct a filter per message class.
 277   std::vector<scoped_refptr<MessageCountFilter> > class_filters;
 278   class_filters.push_back(make_scoped_refptr(
 279       new MessageCountFilter(TestMsgStart)));
 280   class_filters.push_back(make_scoped_refptr(
 281       new MessageCountFilter(UtilityMsgStart)));
 282   for (size_t i = 0; i < class_filters.size(); ++i)
 283     channel_proxy()->AddFilter(class_filters[i].get());
 284
 285   // Send a message for each class; each filter should receive just one message.
 286   sender()->Send(new TestMsg_Bounce());
 287   sender()->Send(new UtilityMsg_Bounce());
 288
 289   // Send some messages not assigned to a specific or valid message class.
 290   sender()->Send(new WorkerMsg_Bounce);
 291
 292   // Each filter should have received just the one sent message of the
 293   // corresponding class.
 294   SendQuitMessageAndWaitForIdle();
 295   for (size_t i = 0; i < class_filters.size(); ++i)
 296     EXPECT_EQ(1U, class_filters[i]->messages_received());
 297 }
 298
 299 TEST_F(IPCChannelProxyTest, GlobalAndMessageClassFilters) {
 300   // Add a class and global filter.
 301   scoped_refptr<MessageCountFilter> class_filter(
 302       new MessageCountFilter(TestMsgStart));
 303   class_filter->set_message_filtering_enabled(false);
 304   channel_proxy()->AddFilter(class_filter.get());
 305
 306   scoped_refptr<MessageCountFilter> global_filter(new MessageCountFilter());
 307   global_filter->set_message_filtering_enabled(false);
 308   channel_proxy()->AddFilter(global_filter.get());
 309
 310   // A message  of class Test should be seen by both the global filter and
 311   // Test-specific filter.
 312   sender()->Send(new TestMsg_Bounce);
 313
 314   // A message of a different class should be seen only by the global filter.
 315   sender()->Send(new UtilityMsg_Bounce);
 316
 317   // Flush all messages.
 318   SendQuitMessageAndWaitForIdle();
 319
 320   // The class filter should have received only the class-specific message.
 321   EXPECT_EQ(1U, class_filter->messages_received());
 322
 323   // The global filter should have received both messages, as well as the final
 324   // QUIT message.
 325   EXPECT_EQ(3U, global_filter->messages_received());
 326 }
 327
 328 TEST_F(IPCChannelProxyTest, FilterRemoval) {
 329   // Add a class and global filter.
 330   scoped_refptr<MessageCountFilter> class_filter(
 331       new MessageCountFilter(TestMsgStart));
 332   scoped_refptr<MessageCountFilter> global_filter(new MessageCountFilter());
 333
 334   // Add and remove both types of filters.
 335   channel_proxy()->AddFilter(class_filter.get());
 336   channel_proxy()->AddFilter(global_filter.get());
 337   channel_proxy()->RemoveFilter(global_filter.get());
 338   channel_proxy()->RemoveFilter(class_filter.get());
 339
 340   // Send some messages; they should not be seen by either filter.
 341   sender()->Send(new TestMsg_Bounce);
 342   sender()->Send(new UtilityMsg_Bounce);
 343
 344   // Ensure that the filters were removed and did not receive any messages.
 345   SendQuitMessageAndWaitForIdle();
 346   EXPECT_EQ(MessageCountFilter::FILTER_REMOVED,
 347             global_filter->last_filter_event());
 348   EXPECT_EQ(MessageCountFilter::FILTER_REMOVED,
 349             class_filter->last_filter_event());
 350   EXPECT_EQ(0U, class_filter->messages_received());
 351   EXPECT_EQ(0U, global_filter->messages_received());
 352 }
 353
 354 // The test that follow trigger DCHECKS in debug build.
 355 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
 356
 357 TEST_F(IPCChannelProxyTest, BadMessageOnListenerThread) {
 358   scoped_refptr<MessageCountFilter> class_filter(
 359       new MessageCountFilter(TestMsgStart));
 360   class_filter->set_message_filtering_enabled(false);
 361   channel_proxy()->AddFilter(class_filter.get());
 362
 363   sender()->Send(new TestMsg_SendBadMessage());
 364
 365   SendQuitMessageAndWaitForIdle();
 366   EXPECT_TRUE(DidListenerGetBadMessage());
 367 }
 368
 369 TEST_F(IPCChannelProxyTest, BadMessageOnIPCThread) {
 370   scoped_refptr<MessageCountFilter> class_filter(
 371       new MessageCountFilter(TestMsgStart));
 372   class_filter->set_message_filtering_enabled(true);
 373   channel_proxy()->AddFilter(class_filter.get());
 374
 375   sender()->Send(new TestMsg_SendBadMessage());
 376
 377   SendQuitMessageAndWaitForIdle();
 378   EXPECT_TRUE(DidListenerGetBadMessage());
 379 }
 380
 381 class IPCChannelBadMessageTest : public IPCTestBase {
 382  public:
 383   IPCChannelBadMessageTest() {}
 384   virtual ~IPCChannelBadMessageTest() {}
 385
 386   virtual void SetUp() OVERRIDE {
 387     IPCTestBase::SetUp();
 388
 389     Init("ChannelProxyClient");
 390
 391     listener_.reset(new QuitListener());
 392     CreateChannel(listener_.get());
 393     ASSERT_TRUE(ConnectChannel());
 394
 395     ASSERT_TRUE(StartClient());
 396   }
 397
 398   virtual void TearDown() {
 399     listener_.reset();
 400     IPCTestBase::TearDown();
 401   }
 402
 403   void SendQuitMessageAndWaitForIdle() {
 404     sender()->Send(new WorkerMsg_Quit);
 405     base::MessageLoop::current()->Run();
 406     EXPECT_TRUE(WaitForClientShutdown());
 407   }
 408
 409   bool DidListenerGetBadMessage() {
 410     return listener_->bad_message_received_;
 411   }
 412
 413  private:
 414   scoped_ptr<QuitListener> listener_;
 415 };
 416
 417 #if !defined(OS_WIN)
 418   // TODO(jam): for some reason this is flaky on win buildbots.
 419 TEST_F(IPCChannelBadMessageTest, BadMessage) {
 420   sender()->Send(new TestMsg_SendBadMessage());
 421   SendQuitMessageAndWaitForIdle();
 422   EXPECT_TRUE(DidListenerGetBadMessage());
 423 }
 424 #endif
 425
 426 #endif
 427
 428 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(ChannelProxyClient) {
 429   base::MessageLoopForIO main_message_loop;
 430   ChannelReflectorListener listener;
 431   scoped_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
 432       IPCTestBase::GetChannelName("ChannelProxyClient"),
 433       &listener));
 434   CHECK(channel->Connect());
 435   listener.Init(channel.get());
 436
 437   base::MessageLoop::current()->Run();
 438   return 0;
 439 }
 440
 441 }  // namespace