Remove Android filter file for ipc_tests.

BUG=339980
TEST=ipc_tests
R=jbudorick@chromium.org,tsepez@chromium.org

Review URL: https://codereview.chromium.org/1259823002

Cr-Commit-Position: refs/heads/master@{#340682}

9 files changed, 141 insertions, 24 deletions

diff --git a/ipc/ipc_channel_posix_unittest.cc b/ipc/ipc_channel_posix_unittest.cc
index 9209d2c..d545e60 100644
--- a/ipc/ipc_channel_posix_unittest.cc
+++ b/ipc/ipc_channel_posix_unittest.cc
@@ -280,7 +280,12 @@ TEST_F(IPCChannelPosixTest, AcceptHangTest) {
   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, out_listener.status());
 }
 
-TEST_F(IPCChannelPosixTest, AdvancedConnected) {
+#if defined(OS_ANDROID)
+#define MAYBE_AdvancedConnected DISABLED_AdvancedConnected
+#else
+#define MAYBE_AdvancedConnected AdvancedConnected
+#endif
+TEST_F(IPCChannelPosixTest, MAYBE_AdvancedConnected) {
   // Test creating a connection to an external process.
   IPCChannelPosixTestListener listener(false);
   IPC::ChannelHandle chan_handle(GetConnectionSocketName());
@@ -309,7 +314,12 @@ TEST_F(IPCChannelPosixTest, AdvancedConnected) {
   unlink(chan_handle.name.c_str());
 }
 
-TEST_F(IPCChannelPosixTest, ResetState) {
+#if defined(OS_ANDROID)
+#define MAYBE_ResetState DISABLED_ResetState
+#else
+#define MAYBE_ResetState ResetState
+#endif
+TEST_F(IPCChannelPosixTest, MAYBE_ResetState) {
   // Test creating a connection to an external process. Close the connection,
   // but continue to listen and make sure another external process can connect
   // to us.
@@ -371,7 +381,12 @@ TEST_F(IPCChannelPosixTest, BadChannelName) {
   EXPECT_FALSE(channel2->Connect());
 }
 
-TEST_F(IPCChannelPosixTest, MultiConnection) {
+#if defined(OS_ANDROID)
+#define MAYBE_MultiConnection DISABLED_MultiConnection
+#else
+#define MAYBE_MultiConnection MultiConnection
+#endif
+TEST_F(IPCChannelPosixTest, MAYBE_MultiConnection) {
   // Test setting up a connection to an external process, and then have
   // another external process attempt to connect to us.
   IPCChannelPosixTestListener listener(false);
diff --git a/ipc/ipc_channel_proxy_unittest.cc b/ipc/ipc_channel_proxy_unittest.cc
index ee5dc22..3ec4c43 100644
--- a/ipc/ipc_channel_proxy_unittest.cc
+++ b/ipc/ipc_channel_proxy_unittest.cc
@@ -269,7 +269,12 @@ class IPCChannelProxyTest : public IPCTestBase {
   scoped_ptr<QuitListener> listener_;
 };
 
-TEST_F(IPCChannelProxyTest, MessageClassFilters) {
+#if defined(OS_ANDROID)
+#define MAYBE_MessageClassFilters DISABLED_MessageClassFilters
+#else
+#define MAYBE_MessageClassFilters MessageClassFilters
+#endif
+TEST_F(IPCChannelProxyTest, MAYBE_MessageClassFilters) {
   // Construct a filter per message class.
   std::vector<scoped_refptr<MessageCountFilter> > class_filters;
   class_filters.push_back(make_scoped_refptr(
@@ -293,7 +298,12 @@ TEST_F(IPCChannelProxyTest, MessageClassFilters) {
     EXPECT_EQ(1U, class_filters[i]->messages_received());
 }
 
-TEST_F(IPCChannelProxyTest, GlobalAndMessageClassFilters) {
+#if defined(OS_ANDROID)
+#define MAYBE_GlobalAndMessageClassFilters DISABLED_GlobalAndMessageClassFilters
+#else
+#define MAYBE_GlobalAndMessageClassFilters GlobalAndMessageClassFilters
+#endif
+TEST_F(IPCChannelProxyTest, MAYBE_GlobalAndMessageClassFilters) {
   // Add a class and global filter.
   scoped_refptr<MessageCountFilter> class_filter(
       new MessageCountFilter(TestMsgStart));
@@ -322,7 +332,12 @@ TEST_F(IPCChannelProxyTest, GlobalAndMessageClassFilters) {
   EXPECT_EQ(3U, global_filter->messages_received());
 }
 
-TEST_F(IPCChannelProxyTest, FilterRemoval) {
+#if defined(OS_ANDROID)
+#define MAYBE_FilterRemoval DISABLED_FilterRemoval
+#else
+#define MAYBE_FilterRemoval FilterRemoval
+#endif
+TEST_F(IPCChannelProxyTest, MAYBE_FilterRemoval) {
   // Add a class and global filter.
   scoped_refptr<MessageCountFilter> class_filter(
       new MessageCountFilter(TestMsgStart));
diff --git a/ipc/ipc_channel_unittest.cc b/ipc/ipc_channel_unittest.cc
index 588426d..3127af7 100644
--- a/ipc/ipc_channel_unittest.cc
+++ b/ipc/ipc_channel_unittest.cc
@@ -22,7 +22,12 @@ namespace {
 class IPCChannelTest : public IPCTestBase {
 };
 
-TEST_F(IPCChannelTest, ChannelTest) {
+#if defined(OS_ANDROID)
+#define MAYBE_ChannelTest DISABLED_ChannelTest
+#else
+#define MAYBE_ChannelTest ChannelTest
+#endif
+TEST_F(IPCChannelTest, MAYBE_ChannelTest) {
   Init("GenericClient");
 
   // Set up IPC channel and start client.
@@ -84,7 +89,12 @@ TEST_F(IPCChannelTest, ChannelTestExistingPipe) {
 }
 #endif  // defined (OS_WIN)
 
-TEST_F(IPCChannelTest, ChannelProxyTest) {
+#if defined(OS_ANDROID)
+#define MAYBE_ChannelProxyTest DISABLED_ChannelProxyTest
+#else
+#define MAYBE_ChannelProxyTest ChannelProxyTest
+#endif
+TEST_F(IPCChannelTest, MAYBE_ChannelProxyTest) {
   Init("GenericClient");
 
   base::Thread thread("ChannelProxyTestServer");
@@ -121,7 +131,7 @@ class ChannelListenerWithOnConnectedSend : public IPC::TestChannelListener {
   }
 };
 
-#if defined(OS_WIN)
+#if defined(OS_WIN) || defined(OS_ANDROID)
 // Acting flakey in Windows. http://crbug.com/129595
 #define MAYBE_SendMessageInChannelConnected DISABLED_SendMessageInChannelConnected
 #else
diff --git a/ipc/ipc_fuzzing_tests.cc b/ipc/ipc_fuzzing_tests.cc
index d3ff1a0..5dfddba 100644
--- a/ipc/ipc_fuzzing_tests.cc
+++ b/ipc/ipc_fuzzing_tests.cc
@@ -88,7 +88,12 @@ TEST(IPCMessageIntegrity, ReadVectorNegativeSize) {
   EXPECT_FALSE(ReadParam(&m, &iter, &vec));
 }
 
-TEST(IPCMessageIntegrity, ReadVectorTooLarge1) {
+#if defined(OS_ANDROID)
+#define MAYBE_ReadVectorTooLarge1 DISABLED_ReadVectorTooLarge1
+#else
+#define MAYBE_ReadVectorTooLarge1 ReadVectorTooLarge1
+#endif
+TEST(IPCMessageIntegrity, MAYBE_ReadVectorTooLarge1) {
   // This was BUG 1006367. This is the large but positive length case. Again
   // we try to hit the non-specialized case vector<P>.
   IPC::Message m(0, 1, IPC::Message::PRIORITY_NORMAL);
@@ -261,9 +266,14 @@ MULTIPROCESS_IPC_TEST_CLIENT_MAIN(FuzzServerClient) {
 class IPCFuzzingTest : public IPCTestBase {
 };
 
+#if defined(OS_ANDROID)
+#define MAYBE_SanityTest DISABLED_SanityTest
+#else
+#define MAYBE_SanityTest SanityTest
+#endif
 // This test makes sure that the FuzzerClientListener and FuzzerServerListener
 // are working properly by generating two well formed IPC calls.
-TEST_F(IPCFuzzingTest, SanityTest) {
+TEST_F(IPCFuzzingTest, MAYBE_SanityTest) {
   Init("FuzzServerClient");
 
   FuzzerClientListener listener;
@@ -286,12 +296,17 @@ TEST_F(IPCFuzzingTest, SanityTest) {
   DestroyChannel();
 }
 
+#if defined(OS_ANDROID)
+#define MAYBE_MsgBadPayloadShort DISABLED_MsgBadPayloadShort
+#else
+#define MAYBE_MsgBadPayloadShort MsgBadPayloadShort
+#endif
 // This test uses a payload that is smaller than expected. This generates an
 // error while unpacking the IPC buffer which in debug trigger an assertion and
 // in release is ignored (!). Right after we generate another valid IPC to make
 // sure framing is working properly.
 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
-TEST_F(IPCFuzzingTest, MsgBadPayloadShort) {
+TEST_F(IPCFuzzingTest, MAYBE_MsgBadPayloadShort) {
   Init("FuzzServerClient");
 
   FuzzerClientListener listener;
@@ -315,11 +330,16 @@ TEST_F(IPCFuzzingTest, MsgBadPayloadShort) {
 }
 #endif
 
+#if defined(OS_ANDROID)
+#define MAYBE_MsgBadPayloadArgs DISABLED_MsgBadPayloadArgs
+#else
+#define MAYBE_MsgBadPayloadArgs MsgBadPayloadArgs
+#endif
 // This test uses a payload that has too many arguments, but so the payload size
 // is big enough so the unpacking routine does not generate an error as in the
 // case of MsgBadPayloadShort test. This test does not pinpoint a flaw (per se)
 // as by design we don't carry type information on the IPC message.
-TEST_F(IPCFuzzingTest, MsgBadPayloadArgs) {
+TEST_F(IPCFuzzingTest, MAYBE_MsgBadPayloadArgs) {
   Init("FuzzServerClient");
 
   FuzzerClientListener listener;
diff --git a/ipc/ipc_message_attachment_set_posix_unittest.cc b/ipc/ipc_message_attachment_set_posix_unittest.cc
index 416a7d2..bd09089 100644
--- a/ipc/ipc_message_attachment_set_posix_unittest.cc
+++ b/ipc/ipc_message_attachment_set_posix_unittest.cc
@@ -81,7 +81,12 @@ TEST(MessageAttachmentSet, MaxSize) {
   set->CommitAll();
 }
 
-TEST(MessageAttachmentSet, SetDescriptors) {
+#if defined(OS_ANDROID)
+#define MAYBE_SetDescriptors DISABLED_SetDescriptors
+#else
+#define MAYBE_SetDescriptors SetDescriptors
+#endif
+TEST(MessageAttachmentSet, MAYBE_SetDescriptors) {
   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
 
   ASSERT_TRUE(set->empty());
@@ -176,7 +181,12 @@ TEST(MessageAttachmentSet, WalkCycle) {
   set->CommitAll();
 }
 
-TEST(MessageAttachmentSet, DontClose) {
+#if defined(OS_ANDROID)
+#define MAYBE_DontClose DISABLED_DontClose
+#else
+#define MAYBE_DontClose DontClose
+#endif
+TEST(MessageAttachmentSet, MAYBE_DontClose) {
   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
 
   const int fd = GetSafeFd();
diff --git a/ipc/ipc_message_unittest.cc b/ipc/ipc_message_unittest.cc
index 5d09a01..aea7054 100644
--- a/ipc/ipc_message_unittest.cc
+++ b/ipc/ipc_message_unittest.cc
@@ -166,7 +166,12 @@ TEST_F(IPCMessageParameterTest, EmptyDispatcherWithParam) {
   EXPECT_TRUE(called_);
 }
 
-TEST_F(IPCMessageParameterTest, OneIntegerWithParam) {
+#if defined(OS_ANDROID)
+#define MAYBE_OneIntegerWithParam DISABLED_OneIntegerWithParam
+#else
+#define MAYBE_OneIntegerWithParam OneIntegerWithParam
+#endif
+TEST_F(IPCMessageParameterTest, MAYBE_OneIntegerWithParam) {
   TestMsgClassI message(42);
   EXPECT_TRUE(OnMessageReceived(message));
   EXPECT_TRUE(called_);
diff --git a/ipc/ipc_send_fds_test.cc b/ipc/ipc_send_fds_test.cc
index 7669c8f..68afb59 100644
--- a/ipc/ipc_send_fds_test.cc
+++ b/ipc/ipc_send_fds_test.cc
@@ -137,7 +137,12 @@ class IPCSendFdsTest : public IPCTestBase {
   }
 };
 
-TEST_F(IPCSendFdsTest, DescriptorTest) {
+#if defined(OS_ANDROID)
+#define MAYBE_DescriptorTest DISABLED_DescriptorTest
+#else
+#define MAYBE_DescriptorTest DescriptorTest
+#endif
+TEST_F(IPCSendFdsTest, MAYBE_DescriptorTest) {
   Init("SendFdsClient");
   RunServer();
 }
diff --git a/ipc/ipc_sync_channel_unittest.cc b/ipc/ipc_sync_channel_unittest.cc
index 1e61a68..314a4b8 100644
--- a/ipc/ipc_sync_channel_unittest.cc
+++ b/ipc/ipc_sync_channel_unittest.cc
@@ -301,8 +301,13 @@ void Simple(bool pump_during_send) {
   RunTest(workers);
 }
 
+#if defined(OS_ANDROID)
+#define MAYBE_Simple DISABLED_Simple
+#else
+#define MAYBE_Simple Simple
+#endif
 // Tests basic synchronous call
-TEST_F(IPCSyncChannelTest, Simple) {
+TEST_F(IPCSyncChannelTest, MAYBE_Simple) {
   Simple(false);
   Simple(true);
 }
@@ -517,8 +522,13 @@ TEST_F(IPCSyncChannelTest, Unblock) {
 
 //------------------------------------------------------------------------------
 
+#if defined(OS_ANDROID)
+#define MAYBE_ChannelDeleteDuringSend DISABLED_ChannelDeleteDuringSend
+#else
+#define MAYBE_ChannelDeleteDuringSend ChannelDeleteDuringSend
+#endif
 // Tests that the the SyncChannel object can be deleted during a Send.
-TEST_F(IPCSyncChannelTest, ChannelDeleteDuringSend) {
+TEST_F(IPCSyncChannelTest, MAYBE_ChannelDeleteDuringSend) {
   Unblock(false, false, true);
   Unblock(false, true, true);
   Unblock(true, false, true);
@@ -868,10 +878,16 @@ void ChattyServer(bool pump_during_send) {
   RunTest(workers);
 }
 
+#if defined(OS_ANDROID)
+// Times out.
+#define MAYBE_ChattyServer DISABLED_ChattyServer
+#else
+#define MAYBE_ChattyServer ChattyServer
+#endif
 // Tests http://b/1093251 - that sending lots of sync messages while
 // the receiver is waiting for a sync reply does not overflow the PostMessage
 // queue.
-TEST_F(IPCSyncChannelTest, ChattyServer) {
+TEST_F(IPCSyncChannelTest, MAYBE_ChattyServer) {
   ChattyServer(false);
   ChattyServer(true);
 }
@@ -911,10 +927,15 @@ class DoneEventRaceServer : public Worker {
   }
 };
 
+#if defined(OS_ANDROID)
+#define MAYBE_DoneEventRace DISABLED_DoneEventRace
+#else
+#define MAYBE_DoneEventRace DoneEventRace
+#endif
 // Tests http://b/1474092 - that if after the done_event is set but before
 // OnObjectSignaled is called another message is sent out, then after its
 // reply comes back OnObjectSignaled will be called for the first message.
-TEST_F(IPCSyncChannelTest, DoneEventRace) {
+TEST_F(IPCSyncChannelTest, MAYBE_DoneEventRace) {
   std::vector<Worker*> workers;
   workers.push_back(new DoneEventRaceServer());
   workers.push_back(new SimpleClient());
@@ -1563,7 +1584,13 @@ class RestrictedDispatchPipeWorker : public Worker {
   int* success_;
 };
 
-TEST_F(IPCSyncChannelTest, RestrictedDispatch4WayDeadlock) {
+#if defined(OS_ANDROID)
+#define MAYBE_RestrictedDispatch4WayDeadlock \
+  DISABLED_RestrictedDispatch4WayDeadlock
+#else
+#define MAYBE_RestrictedDispatch4WayDeadlock RestrictedDispatch4WayDeadlock
+#endif
+TEST_F(IPCSyncChannelTest, MAYBE_RestrictedDispatch4WayDeadlock) {
   int success = 0;
   std::vector<Worker*> workers;
   WaitableEvent event0(true, false);
diff --git a/ipc/sync_socket_unittest.cc b/ipc/sync_socket_unittest.cc
index 0172c2f..edda3c4 100644
--- a/ipc/sync_socket_unittest.cc
+++ b/ipc/sync_socket_unittest.cc
@@ -166,7 +166,12 @@ class SyncSocketClientListener : public IPC::Listener {
 class SyncSocketTest : public IPCTestBase {
 };
 
-TEST_F(SyncSocketTest, SanityTest) {
+#if defined(OS_ANDROID)
+#define MAYBE_SanityTest DISABLED_SanityTest
+#else
+#define MAYBE_SanityTest SanityTest
+#endif
+TEST_F(SyncSocketTest, MAYBE_SanityTest) {
   Init("SyncSocketServerClient");
 
   SyncSocketClientListener listener;
@@ -248,8 +253,13 @@ TEST_F(SyncSocketTest, DisconnectTest) {
   EXPECT_EQ(0U, received);
 }
 
+#if defined(OS_ANDROID)
+#define MAYBE_BlockingReceiveTest DISABLED_BlockingReceiveTest
+#else
+#define MAYBE_BlockingReceiveTest BlockingReceiveTest
+#endif
 // Tests that read is a blocking operation.
-TEST_F(SyncSocketTest, BlockingReceiveTest) {
+TEST_F(SyncSocketTest, MAYBE_BlockingReceiveTest) {
   base::CancelableSyncSocket pair[2];
   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));