Update mojo sdk to rev cc531b32182099a5a034a99daff35ed5d38a61c8

mojo/public/cpp/utility/lib/run_loop.cc

 // Copyright 2014 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 "mojo/public/cpp/utility/run_loop.h"
 
 #include <assert.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 126 matching lines @@
 }
 
 void RunLoop::PostDelayedTask(const Closure& task, MojoTimeTicks delay) {
   assert(current() == this);
   MojoTimeTicks run_time = delay + GetTimeTicksNow();
   delayed_tasks_.push(PendingTask(task, run_time, next_sequence_number_++));
 }
 
 bool RunLoop::Wait(bool non_blocking) {
   const WaitState wait_state = GetWaitState(non_blocking);
-  if (wait_state.handles.empty() && delayed_tasks_.empty()) {
-    Quit();
+  if (wait_state.handles.empty()) {
+    if (delayed_tasks_.empty())
+      Quit();
     return false;
   }
 
-  const MojoResult result = WaitMany(
-      wait_state.handles, wait_state.handle_signals, wait_state.deadline);
-  if (result >= 0) {
-    const size_t index = static_cast<size_t>(result);
-    assert(handler_data_.find(wait_state.handles[index]) !=
-           handler_data_.end());
-    handler_data_[wait_state.handles[index]].handler->OnHandleReady(
-        wait_state.handles[index]);
-    return true;
+  const WaitManyResult wmr =
+      WaitMany(wait_state.handles, wait_state.handle_signals,
+               wait_state.deadline, nullptr);
+
+  if (!wmr.IsIndexValid()) {
+    assert(wmr.result == MOJO_RESULT_DEADLINE_EXCEEDED);
+    return NotifyHandlers(MOJO_RESULT_DEADLINE_EXCEEDED, CHECK_DEADLINE);
   }
 
-  switch (result) {
+  Handle handle = wait_state.handles[wmr.index];
+  assert(handler_data_.find(handle) != handler_data_.end());
+  RunLoopHandler* handler = handler_data_[handle].handler;
+
+  switch (wmr.result) {
+    case MOJO_RESULT_OK:
+      handler->OnHandleReady(handle);
+      return true;
     case MOJO_RESULT_INVALID_ARGUMENT:
     case MOJO_RESULT_FAILED_PRECONDITION:
-      return RemoveFirstInvalidHandle(wait_state);
-    case MOJO_RESULT_DEADLINE_EXCEEDED:
-      return NotifyHandlers(MOJO_RESULT_DEADLINE_EXCEEDED, CHECK_DEADLINE);
+      // Remove the handle first, this way if OnHandleError() tries to remove
+      // the handle our iterator isn't invalidated.
+      handler_data_.erase(handle);
+      handler->OnHandleError(handle, wmr.result);
+      return true;
+    default:
+      assert(false);
+      return false;
   }
-
-  assert(false);
-  return false;
 }
 
 bool RunLoop::NotifyHandlers(MojoResult error, CheckDeadline check) {
   bool notified = false;
 
   // Make a copy in case someone tries to add/remove new handlers as part of
   // notifying.
   const HandleToHandlerData cloned_handlers(handler_data_);
   const MojoTimeTicks now(GetTimeTicksNow());
   for (HandleToHandlerData::const_iterator i = cloned_handlers.begin();
@@ skipping 14 matching lines @@
 
     RunLoopHandler* handler = i->second.handler;
     handler_data_.erase(i->first);
     handler->OnHandleError(i->first, error);
     notified = true;
   }
 
   return notified;
 }
 
-bool RunLoop::RemoveFirstInvalidHandle(const WaitState& wait_state) {
-  for (size_t i = 0; i < wait_state.handles.size(); ++i) {
-    const MojoResult result = mojo::Wait(wait_state.handles[i],
-                                         wait_state.handle_signals[i],
-                                         static_cast<MojoDeadline>(0));
-    if (result == MOJO_RESULT_INVALID_ARGUMENT ||
-        result == MOJO_RESULT_FAILED_PRECONDITION) {
-      // Remove the handle first, this way if OnHandleError() tries to remove
-      // the handle our iterator isn't invalidated.
-      assert(handler_data_.find(wait_state.handles[i]) != handler_data_.end());
-      RunLoopHandler* handler = handler_data_[wait_state.handles[i]].handler;
-      handler_data_.erase(wait_state.handles[i]);
-      handler->OnHandleError(wait_state.handles[i], result);
-      return true;
-    }
-    assert(MOJO_RESULT_DEADLINE_EXCEEDED == result || MOJO_RESULT_OK == result);
-  }
-  return false;
-}
-
 RunLoop::WaitState RunLoop::GetWaitState(bool non_blocking) const {
   WaitState wait_state;
   MojoTimeTicks min_time = kInvalidTimeTicks;
   for (HandleToHandlerData::const_iterator i = handler_data_.begin();
        i != handler_data_.end();
        ++i) {
     wait_state.handles.push_back(i->first);
     wait_state.handle_signals.push_back(i->second.handle_signals);
     if (!non_blocking && i->second.deadline != kInvalidTimeTicks &&
         (min_time == kInvalidTimeTicks || i->second.deadline < min_time)) {
@@ skipping 33 matching lines @@
     // std::priority_queue<> puts the least element at the end of the queue. We
     // want the soonest eligible task to be at the head of the queue, so
     // run_times further in the future are considered lesser.
     return run_time > other.run_time;
   }
 
   return sequence_number > other.sequence_number;
 }
 
 }  // namespace mojo