Remove Windows support from the EDK.

mojo/edk/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::EpsilonDeadline()| may be increased to
 // increase tolerance and reduce observed flakiness (though doing so reduces the
 // meaningfulness of the test).
 
 #include "mojo/edk/system/simple_dispatcher.h"
@@ skipping 64 matching lines @@
   HandleSignalsState GetHandleSignalsStateImplNoLock() const override {
     mutex().AssertHeld();
     return state_;
   }
 
   HandleSignalsState state_ MOJO_GUARDED_BY(mutex());
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(MockSimpleDispatcher);
 };
 
-#if defined(OS_WIN)
-// http://crbug.com/396404
-#define MAYBE_Basic DISABLED_Basic
-#else
-#define MAYBE_Basic Basic
-#endif
-TEST(SimpleDispatcherTest, MAYBE_Basic) {
+TEST(SimpleDispatcherTest, Basic) {
   test::Stopwatch stopwatch;
 
   scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
   Waiter w;
   uint32_t context = 0;
   HandleSignalsState hss;
 
   // Try adding a readable waiter when already readable.
   w.Init();
   d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
@@ skipping 212 matching lines @@
             d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr));
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   stopwatch.Start();
   EXPECT_EQ(MOJO_RESULT_CANCELLED,
             w.Wait(2 * test::EpsilonDeadline(), &context));
   EXPECT_LT(stopwatch.Elapsed(), test::EpsilonDeadline());
   EXPECT_EQ(4u, context);
   // Don't need to remove waiters from closed dispatchers.
 }
 
-#if defined(OS_WIN)
-// http://crbug.com/396393
-#define MAYBE_BasicThreaded DISABLED_BasicThreaded
-#else
-#define MAYBE_BasicThreaded BasicThreaded
-#endif
-TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) {
+TEST(SimpleDispatcherTest, BasicThreaded) {
   test::Stopwatch stopwatch;
   bool did_wait;
   MojoResult result;
   uint32_t context;
   HandleSignalsState hss;
 
   // Wait for readable (already readable).
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     {
@@ skipping 100 matching lines @@
   elapsed = stopwatch.Elapsed();
   EXPECT_GT(elapsed, (2 - 1) * test::EpsilonDeadline());
   EXPECT_LT(elapsed, (2 + 1) * test::EpsilonDeadline());
   EXPECT_TRUE(did_wait);
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, result);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
 }
 
-#if defined(OS_WIN)
-// http://crbug.com/387124
-#define MAYBE_MultipleWaiters DISABLED_MultipleWaiters
-#else
-#define MAYBE_MultipleWaiters MultipleWaiters
-#endif
-TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) {
+TEST(SimpleDispatcherTest, MultipleWaiters) {
   static const uint32_t kNumWaiters = 20;
 
   bool did_wait[kNumWaiters];
   MojoResult result[kNumWaiters];
   uint32_t context[kNumWaiters];
   HandleSignalsState hss[kNumWaiters];
 
   // All wait for readable and becomes readable after some time.
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
@@ skipping 126 matching lines @@
     // Since we closed before joining, we can't say much about what each thread
     // saw as the state.
   }
 }
 
 // TODO(vtl): Stress test?
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo