Disable all the tests that are flaking more than 5% on Windows builders.

mojo/system/simple_dispatcher_unittest.cc

 // Copyright 2013 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.
 
 // NOTE(vtl): Some of these tests are inherently flaky (e.g., if run on a
 // heavily-loaded system). Sorry. |test::EpsilonTimeout()| may be increased to
 // increase tolerance and reduce observed flakiness (though doing so reduces the
 // meaningfulness of the test).
 
 #include "mojo/system/simple_dispatcher.h"
@@ skipping 69 matching lines @@
     lock().AssertAcquired();
     return state_;
   }
 
   // Protected by |lock()|:
   HandleSignalsState state_;
 
   DISALLOW_COPY_AND_ASSIGN(MockSimpleDispatcher);
 };
 
-TEST(SimpleDispatcherTest, Basic) {
+#if defined(OS_WIN)
+// http://crbug.com/396404
+#define MAYBE_Basic DISABLED_Basic
+#else
+#define MAYBE_Basic Basic
+#endif
+TEST(SimpleDispatcherTest, MAYBE_Basic) {
   test::Stopwatch stopwatch;
 
   scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
   Waiter w;
   uint32_t context = 0;
 
   // Try adding a readable waiter when already readable.
   w.Init();
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
   EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
@@ skipping 160 matching lines @@
   ASSERT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4));
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_CANCELLED,
             w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout());
   EXPECT_EQ(4u, context);
   // Don't need to remove waiters from closed dispatchers.
 }
 
-TEST(SimpleDispatcherTest, BasicThreaded) {
+#if defined(OS_WIN)
+// http://crbug.com/396393
+#define MAYBE_BasicThreaded DISABLED_BasicThreaded
+#else
+#define MAYBE_BasicThreaded BasicThreaded
+#endif
+TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) {
   test::Stopwatch stopwatch;
   bool did_wait;
   MojoResult result;
   uint32_t context;
 
   // Wait for readable (already readable).
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     {
       d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
@@ skipping 92 matching lines @@
     // If we closed earlier, then probably we'd get a |MOJO_RESULT_CANCELLED|.
     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   }
   elapsed = stopwatch.Elapsed();
   EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout());
   EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout());
   EXPECT_TRUE(did_wait);
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, result);
 }
 
-TEST(SimpleDispatcherTest, MultipleWaiters) {
+#if defined(OS_WIN)
+// http://crbug.com/387124
+#define MAYBE_MultipleWaiters DISABLED_MultipleWaiters
+#else
+#define MAYBE_MultipleWaiters MultipleWaiters
+#endif
+TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) {
   static const uint32_t kNumWaiters = 20;
 
   bool did_wait[kNumWaiters];
   MojoResult result[kNumWaiters];
   uint32_t context[kNumWaiters];
 
   // All wait for readable and becomes readable after some time.
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     ScopedVector<test::WaiterThread> threads;
@@ skipping 137 matching lines @@
     EXPECT_TRUE(did_wait[i]);
     EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, result[i]);
   }
 }
 
 // TODO(vtl): Stress test?
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo