Re-enable multi-process IPC tests on Android.

ipc/ipc_channel_proxy_unittest.cc

 // 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>
 
@@ skipping 255 matching lines @@
 
   bool DidListenerGetBadMessage() {
     return listener_->bad_message_received_;
   }
 
  private:
   std::unique_ptr<base::Thread> thread_;
   std::unique_ptr<QuitListener> listener_;
 };
 
-#if defined(OS_ANDROID)
-#define MAYBE_MessageClassFilters DISABLED_MessageClassFilters
-#else
-#define MAYBE_MessageClassFilters MessageClassFilters
-#endif
-TEST_F(IPCChannelProxyTest, MAYBE_MessageClassFilters) {
+TEST_F(IPCChannelProxyTest, MessageClassFilters) {
   // Construct a filter per message class.
   std::vector<scoped_refptr<MessageCountFilter> > class_filters;
   class_filters.push_back(make_scoped_refptr(
       new MessageCountFilter(TestMsgStart)));
   class_filters.push_back(make_scoped_refptr(
       new MessageCountFilter(UtilityMsgStart)));
   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 UtilityMsg_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());
 }
 
-#if defined(OS_ANDROID)
-#define MAYBE_GlobalAndMessageClassFilters DISABLED_GlobalAndMessageClassFilters
-#else
-#define MAYBE_GlobalAndMessageClassFilters GlobalAndMessageClassFilters
-#endif
-TEST_F(IPCChannelProxyTest, MAYBE_GlobalAndMessageClassFilters) {
+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 UtilityMsg_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());
 }
 
-#if defined(OS_ANDROID)
-#define MAYBE_FilterRemoval DISABLED_FilterRemoval
-#else
-#define MAYBE_FilterRemoval FilterRemoval
-#endif
-TEST_F(IPCChannelProxyTest, MAYBE_FilterRemoval) {
+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());
@@ skipping 89 matching lines @@
   std::unique_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
       IPCTestBase::GetChannelName("ChannelProxyClient"), &listener));
   CHECK(channel->Connect());
   listener.Init(channel.get());
 
   base::MessageLoop::current()->Run();
   return 0;
 }
 
 }  // namespace