Add mojo/c/system/{time.h,wait.h}.

mojo/public/python/mojo_system.pyx

 # 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.
 
 # distutils language = c++
 
 cimport c_core
 cimport c_export  # needed so the init function gets exported
 cimport c_thunks
 
@@ skipping 57 matching lines @@
 READ_DATA_FLAG_QUERY = c_core.MOJO_READ_DATA_FLAG_QUERY
 READ_DATA_FLAG_PEEK = c_core.MOJO_READ_DATA_FLAG_PEEK
 MAP_BUFFER_FLAG_NONE = c_core.MOJO_MAP_BUFFER_FLAG_NONE
 
 _WAITMANY_NO_SIGNAL_STATE_ERRORS = [RESULT_INVALID_ARGUMENT,
                                     RESULT_RESOURCE_EXHAUSTED]
 
 def GetTimeTicksNow():
   """Monotonically increasing tick count representing "right now."
 
-  See mojo/public/c/system/functions.h
+  See mojo/public/c/system/time.h
   """
   return c_core.MojoGetTimeTicksNow()
 
 cdef class _ScopedMemory:
   """Allocate memory at creation, and deallocate it at destruction."""
   cdef void* memory
   def __init__(self, size):
     self.memory = PyMem_Malloc(size)
 
   def __dealloc__(self):
@@ skipping 107 matching lines @@
 
   def __init__(self, mojo_result):
     self.mojo_result = mojo_result
 
 def WaitMany(handles_and_signals, deadline):
   """Waits on a list of handles.
 
   Args:
     handles_and_signals: list of tuples of handle and signal.
 
-  See mojo/public/c/system/functions.h
+  See mojo/public/c/system/wait.h
   """
   cdef uint32_t length = len(handles_and_signals)
   cdef uint32_t result_index = <uint32_t>(-1)
 
   cdef _ScopedMemory handles_alloc = _ScopedMemory(
       sizeof(c_core.MojoHandle) * length)
   cdef _ScopedMemory signals_alloc = _ScopedMemory(
       sizeof(c_core.MojoHandleSignals) * length)
   cdef _ScopedMemory states_alloc = _ScopedMemory(
       sizeof(c_core.MojoHandleSignalsState) * length)
@@ skipping 119 matching lines @@
     else:
       return not equality
 
   def IsValid(self):
     """Returns whether this handle is valid."""
     return self._mojo_handle != c_core.MOJO_HANDLE_INVALID
 
   def Close(self):
     """Closes this handle.
 
-    See mojo/public/c/system/functions.h
+    See mojo/public/c/system/handle.h
     """
     cdef c_core.MojoResult result = c_core.MOJO_RESULT_OK
     if self.IsValid():
       result = c_core.MojoClose(self._mojo_handle)
       self._Invalidate()
     return result
 
   def __dealloc__(self):
     self.Close()
 
   def Wait(self, signals, deadline):
     """Waits on the given handle.
 
-    See mojo/public/c/system/functions.h
+    See mojo/public/c/system/wait.h
     """
     cdef c_core.MojoHandle handle = self._mojo_handle
     cdef c_core.MojoHandleSignals csignals = signals
     cdef c_core.MojoDeadline cdeadline = deadline
     cdef c_core.MojoHandleSignalsState signal_states
     cdef c_core.MojoResult result
     with nogil:
       result = c_core.MojoWait(handle, csignals, cdeadline, &signal_states)
 
     returned_states = None
@@ skipping 416 matching lines @@
     return self.__run_loop.PostDelayedTask(runnable, delay)
 
   @staticmethod
   def Current():
     if hasattr(_RUN_LOOPS, 'loop'):
       return _RUN_LOOPS.loop()
     return None
 
 
 _ASYNC_WAITER = mojo_system_impl.AsyncWaiter()