Mojo EDK: Circulate MojoArmWatcher outputs to avoid starvation

mojo/edk/system/watcher_unittest.cc

 // Copyright 2017 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 <stdint.h>
 
 #include <map>
 #include <memory>
+#include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "base/time/time.h"
 #include "mojo/edk/test/mojo_test_base.h"
@@ skipping 1559 matching lines @@
   context = helper.CreateContextWithCancel(WatchHelper::ContextCallback(),
                                            signal_event);
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoWatch(w, b, MOJO_HANDLE_SIGNAL_READABLE, context));
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(w));
   event.Wait();
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
 }
 
+TEST_F(WatcherTest, ArmFailureCirculation) {
+  // Sanity check to ensure that all ready handles will eventually be returned
+  // over a finite number of calls to MojoArmWatcher().
+
+  constexpr size_t kNumTestPipes = 100;
+  constexpr size_t kNumTestHandles = kNumTestPipes * 2;
+  MojoHandle handles[kNumTestHandles];
+
+  // Create a bunch of pipes and make sure they're all readable.
+  for (size_t i = 0; i < kNumTestPipes; ++i) {
+    CreateMessagePipe(&handles[i], &handles[i + kNumTestPipes]);
+    WriteMessage(handles[i], "hey");
+    WriteMessage(handles[i + kNumTestPipes], "hay");
+    WaitForSignals(handles[i], MOJO_HANDLE_SIGNAL_READABLE);
+    WaitForSignals(handles[i + kNumTestPipes], MOJO_HANDLE_SIGNAL_READABLE);
+  }
+
+  // Create a watcher and watch all of them.
+  MojoHandle w;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoCreateWatcher(&ExpectOnlyCancel, &w));
+  for (size_t i = 0; i < kNumTestHandles; ++i) {
+    EXPECT_EQ(MOJO_RESULT_OK,
+              MojoWatch(w, handles[i], MOJO_HANDLE_SIGNAL_READABLE, i));
+  }
+
+  // Keep trying to arm |w| until every watch gets an entry in |ready_contexts|.
+  // If MojoArmWatcher() is well-behaved, this should terminate eventually.
+  std::set<uintptr_t> ready_contexts;
+  while (ready_contexts.size() < kNumTestHandles) {
+    uint32_t num_ready_contexts = 1;
+    uintptr_t ready_context;
+    MojoResult ready_result;
+    MojoHandleSignalsState ready_state;
+    EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
+              MojoArmWatcher(w, &num_ready_contexts, &ready_context,
+                             &ready_result, &ready_state));
+    EXPECT_EQ(1u, num_ready_contexts);
+    EXPECT_EQ(MOJO_RESULT_OK, ready_result);
+    ready_contexts.insert(ready_context);
+  }
+
+  for (size_t i = 0; i < kNumTestHandles; ++i)
+    EXPECT_EQ(MOJO_RESULT_OK, MojoClose(handles[i]));
+  EXPECT_EQ(MOJO_RESULT_OK, MojoClose(w));
+}
+
 }  // namespace
 }  // namespace edk
 }  // namespace mojo