Mojo: MojoWaitFlags -> MojoHandleSignals.

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>
 
 #include "mojo/public/cpp/utility/lib/thread_local.h"
 #include "mojo/public/cpp/utility/run_loop_handler.h"
 
 namespace mojo {
 namespace {
 
 internal::ThreadLocalPointer<RunLoop> current_run_loop;
 
 const MojoTimeTicks kInvalidTimeTicks = static_cast<MojoTimeTicks>(0);
 
 }  // namespace
 
 // State needed for one iteration of WaitMany().
 struct RunLoop::WaitState {
   WaitState() : deadline(MOJO_DEADLINE_INDEFINITE) {}
 
   std::vector<Handle> handles;
-  std::vector<MojoWaitFlags> wait_flags;
+  std::vector<MojoHandleSignals> handle_signals;
   MojoDeadline deadline;
 };
 
 struct RunLoop::RunState {
   RunState() : should_quit(false) {}
 
   bool should_quit;
 };
 
 RunLoop::RunLoop() : run_state_(NULL), next_handler_id_(0) {
@@ skipping 17 matching lines @@
   current_run_loop.Free();
 }
 
 // static
 RunLoop* RunLoop::current() {
   return current_run_loop.Get();
 }
 
 void RunLoop::AddHandler(RunLoopHandler* handler,
                          const Handle& handle,
-                         MojoWaitFlags wait_flags,
+                         MojoHandleSignals handle_signals,
                          MojoDeadline deadline) {
   assert(current() == this);
   assert(handler);
   assert(handle.is_valid());
   // Assume it's an error if someone tries to reregister an existing handle.
   assert(0u == handler_data_.count(handle));
   HandlerData handler_data;
   handler_data.handler = handler;
-  handler_data.wait_flags = wait_flags;
+  handler_data.handle_signals = handle_signals;
   handler_data.deadline = (deadline == MOJO_DEADLINE_INDEFINITE) ?
       kInvalidTimeTicks :
       GetTimeTicksNow() + static_cast<MojoTimeTicks>(deadline);
   handler_data.id = next_handler_id_++;
   handler_data_[handle] = handler_data;
 }
 
 void RunLoop::RemoveHandler(const Handle& handle) {
   assert(current() == this);
   handler_data_.erase(handle);
@@ skipping 31 matching lines @@
     run_state_->should_quit = true;
 }
 
 bool RunLoop::Wait(bool non_blocking) {
   const WaitState wait_state = GetWaitState(non_blocking);
   if (wait_state.handles.empty()) {
     Quit();
     return false;
   }
 
-  const MojoResult result =
-      WaitMany(wait_state.handles, wait_state.wait_flags, wait_state.deadline);
+  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;
   }
 
   switch (result) {
@@ skipping 28 matching lines @@
       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.wait_flags[i],
+        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);
   }
   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.wait_flags.push_back(i->second.wait_flags);
+    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)) {
       min_time = i->second.deadline;
     }
   }
   if (non_blocking) {
     wait_state.deadline = static_cast<MojoDeadline>(0);
   } else if (min_time != kInvalidTimeTicks) {
     const MojoTimeTicks now = GetTimeTicksNow();
     if (min_time < now)
       wait_state.deadline = static_cast<MojoDeadline>(0);
     else
       wait_state.deadline = static_cast<MojoDeadline>(min_time - now);
   }
   return wait_state;
 }
 
 }  // namespace mojo