Remove Android filter file for ipc_tests.

ipc/ipc_sync_channel_unittest.cc

 // Copyright (c) 2012 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 "ipc/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 283 matching lines @@
   }
 };
 
 void Simple(bool pump_during_send) {
   std::vector<Worker*> workers;
   workers.push_back(new SimpleServer(pump_during_send));
   workers.push_back(new SimpleClient());
   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);
 }
 
 //------------------------------------------------------------------------------
 
 // Worker classes which override how the sync channel is created to use the
 // two-step initialization (calling the lightweight constructor and then
 // ChannelProxy::Init separately) process.
 class TwoStepServer : public Worker {
@@ skipping 194 matching lines @@
 // Tests that the caller unblocks to answer a sync message from the receiver.
 TEST_F(IPCSyncChannelTest, Unblock) {
   Unblock(false, false, false);
   Unblock(false, true, false);
   Unblock(true, false, false);
   Unblock(true, true, false);
 }
 
 //------------------------------------------------------------------------------
 
+#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);
   Unblock(true, true, true);
 }
 
 //------------------------------------------------------------------------------
 
 class RecursiveServer : public Worker {
  public:
@@ skipping 329 matching lines @@
   }
 };
 
 void ChattyServer(bool pump_during_send) {
   std::vector<Worker*> workers;
   workers.push_back(new UnblockServer(pump_during_send, false));
   workers.push_back(new ChattyClient());
   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);
 }
 
 //------------------------------------------------------------------------------
 
 void NestedCallback(Worker* server) {
   // Sleep a bit so that we wake up after the reply has been received.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(250));
   server->SendAnswerToLife(true, true);
@@ skipping 19 matching lines @@
     // Even though we have a timeout on the Send, it will succeed since for this
     // bug, the reply message comes back and is deserialized, however the done
     // event wasn't set.  So we indirectly use the timeout task to notice if a
     // timeout occurred.
     SendAnswerToLife(true, true);
     DCHECK(!timeout_occurred);
     Done();
   }
 };
 
+#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());
   RunTest(workers);
 }
 
 //------------------------------------------------------------------------------
 
 class TestSyncMessageFilter : public SyncMessageFilter {
  public:
@@ skipping 628 matching lines @@
   }
 
   scoped_ptr<SyncChannel> other_channel_;
   WaitableEvent* event1_;
   WaitableEvent* event2_;
   std::string other_channel_name_;
   int group_;
   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);
   WaitableEvent event1(true, false);
   WaitableEvent event2(true, false);
   WaitableEvent event3(true, false);
   workers.push_back(new RestrictedDispatchPipeWorker(
         "channel0", &event0, "channel1", &event1, 1, &success));
   workers.push_back(new RestrictedDispatchPipeWorker(
         "channel1", &event1, "channel2", &event2, 2, NULL));
@@ skipping 196 matching lines @@
 }
 
 // Windows needs to send an out-of-band secret to verify the client end of the
 // channel. Test that we still connect correctly in that case.
 TEST_F(IPCSyncChannelTest, Verified) {
   Verified();
 }
 
 }  // namespace
 }  // namespace IPC