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

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

Index: mojo/public/rust/src/system/handle.rs
diff --git a/mojo/public/rust/src/system/handle.rs b/mojo/public/rust/src/system/handle.rs
deleted file mode 100644
index 241343e1b137d9a0def140b183945010fad4ef63..0000000000000000000000000000000000000000
--- a/mojo/public/rust/src/system/handle.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-// 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.
-
-//! The way Mojo handles are handled in Rust is very similar
-//! to Go, though more type-safe. Here we define an "untyped"
-//! handle which means that what the handle actually represents
-//! is unknown. This is the basic handle wrapper, and it handles
-//! closing the handle once the wrapper goes out of scope, therefore
-//! preventing any resources from being leaked. "Typed" handles
-//! are MessageEndpoints or Consumers/Producers in this library
-//! and they represent handles which represent parts of message pipes,
-//! data pipes, and shared buffers. Typed handles wrap untyped handles
-//! but act much the same as untyped handles.
-
-use system::ffi;
-// This full import is intentional; nearly every type in mojo_types needs to be used.
-use system::mojo_types::*;
-
-/// The CastHandle trait defines an interface to convert between
-/// typed and untyped handles. These are only used internally for
-/// typed handles.
-pub trait CastHandle {
-    /// Passes an ownership of an untyped handle and produces a
-    /// typed handle which owns that untyped handle
-    ///
-    /// Casting to a typed handle is unsafe because the handle may
-    /// not necessarily be a handle to the typed primitive being
-    /// casted to internally in Mojo
-    unsafe fn from_untyped(handle: UntypedHandle) -> Self;
-
-    /// Consumes a typed handle and releases ownership of the
-    /// untyped handle it owned
-    fn as_untyped(self) -> UntypedHandle;
-}
-
-/// The Handle trait simply means that we can extract
-/// the native integer-based Mojo handle from the typed handle.
-pub trait Handle {
-    /// Returns the native handle wrapped by whatever structure
-    /// implements this trait.
-    fn get_native_handle(&self) -> MojoHandle;
-
-    /// Waits on the handle wrapped in the current struct until the signals
-    /// declared in 'signals' are triggered, waiting for a maximum time of
-    /// 'deadline'. This method blocks.
-    ///
-    /// Returns the satisfied and satisfiable signals respectively for this
-    /// handle when waiting is done.
-    fn wait(&self, signals: HandleSignals, deadline: MojoDeadline) -> (SignalsState, MojoResult) {
-        let mut state: SignalsState = Default::default();
-        let r = unsafe {
-            ffi::MojoWait(self.get_native_handle(),
-                          signals,
-                          deadline,
-                          &mut state as *mut SignalsState)
-        };
-        (state, MojoResult::from_code(r))
-    }
-}
-
-/// The basic untyped handle that wraps a MojoHandle (a u32)
-pub struct UntypedHandle {
-    /// The native Mojo handle
-    value: MojoHandle,
-}
-
-impl UntypedHandle {
-    /// Invalidates the Handle by setting its native handle to
-    /// zero, the canonical invalid handle in Mojo.
-    ///
-    /// This function is unsafe because clearing a native handle
-    /// without closing it is a resource leak.
-    pub unsafe fn invalidate(&mut self) {
-        self.value = 0
-    }
-
-    /// Checks if the native handle is valid (0 = canonical invalid handle).
-    pub fn is_valid(&self) -> bool {
-        self.value != 0
-    }
-}
-
-impl Handle for UntypedHandle {
-    /// Pulls out a copy of the native handle wrapped by this structure.
-    fn get_native_handle(&self) -> MojoHandle {
-        self.value
-    }
-}
-
-impl CastHandle for UntypedHandle {
-    /// Casting an untyped handle is a no-op, but we include
-    /// this to eliminate code duplication.
-    unsafe fn from_untyped(handle: UntypedHandle) -> Self {
-        handle
-    }
-
-    /// Casting to an untyped handle is a no-op, but we include
-    /// this to eliminate code duplication.
-    fn as_untyped(self) -> UntypedHandle {
-        self
-    }
-}
-
-impl Drop for UntypedHandle {
-    /// The destructor for an untyped handle which closes the native handle
-    /// it wraps.
-    fn drop(&mut self) {
-        if self.is_valid() {
-            let result = MojoResult::from_code(unsafe { ffi::MojoClose(self.get_native_handle()) });
-            if result != MojoResult::Okay {
-                panic!("Failed to close handle! Reason: {}", result);
-            }
-        }
-    }
-}
-
-/// Acquires a native handle by wrapping it in an untyped handle, allowing
-/// us to track the resource and free it appropriately
-pub unsafe fn acquire(handle: MojoHandle) -> UntypedHandle {
-    UntypedHandle { value: handle }
-}