Make the fuchsia mojo/public repo the source of truth.

mojo/public/rust/src/system/core.rs

-// Copyright 2016 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.
-
-use std::ptr;
-use std::u32;
-use std::vec;
-
-use system::ffi;
-// This full import is intentional; nearly every type in mojo_types needs to be used.
-use system::mojo_types::*;
-use system::handle;
-
-/// Get the time ticks now according to the Mojo IPC. As
-/// can be seen in the documentation for the Mojo C API,
-/// time ticks are meaningless in an absolute sense. Instead,
-/// one should compare the results of two of these calls to
-/// get a proper notion of time passing.
-pub fn get_time_ticks_now() -> MojoTimeTicks {
-    unsafe { ffi::MojoGetTimeTicksNow() }
-}
-
-/// Waits on many handles (or rather any structures that wrap
-/// handles) until the signals declared in 'signals' for each handle
-/// are triggered, waiting for a maximum global time of 'deadline'.
-/// This function blocks.
-pub fn wait_many(handles: &[&handle::Handle],
-                 signals: &[HandleSignals],
-                 states: &mut [SignalsState],
-                 deadline: MojoDeadline)
-                 -> (i32, MojoResult) {
-    assert_eq!(handles.len(), signals.len());
-    assert!(states.len() == handles.len() || states.len() == 0);
-    let num_inputs = handles.len();
-    if num_inputs == 0 {
-        let result = MojoResult::from_code(unsafe {
-            ffi::MojoWaitMany(ptr::null(),
-                              ptr::null(),
-                              0,
-                              deadline,
-                              ptr::null_mut(),
-                              ptr::null_mut())
-        });
-        return (-1, result);
-    }
-    let states_ptr = if states.len() != 0 {
-        states.as_mut_ptr()
-    } else {
-        ptr::null_mut()
-    };
-    let mut index: u32 = u32::MAX;
-    let result = unsafe {
-        let mut raw_handles: vec::Vec<MojoHandle> = vec::Vec::with_capacity(num_inputs);
-        for handle in handles.iter() {
-            raw_handles.push(handle.get_native_handle())
-        }
-        MojoResult::from_code(ffi::MojoWaitMany(raw_handles.as_ptr(),
-                                                signals.as_ptr(),
-                                                num_inputs as u32,
-                                                deadline,
-                                                &mut index as *mut u32,
-                                                states_ptr))
-    };
-    (index as i32, result)
-}