| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 //! The way Mojo handles are handled in Rust is very similar | |
| 6 //! to Go, though more type-safe. Here we define an "untyped" | |
| 7 //! handle which means that what the handle actually represents | |
| 8 //! is unknown. This is the basic handle wrapper, and it handles | |
| 9 //! closing the handle once the wrapper goes out of scope, therefore | |
| 10 //! preventing any resources from being leaked. "Typed" handles | |
| 11 //! are MessageEndpoints or Consumers/Producers in this library | |
| 12 //! and they represent handles which represent parts of message pipes, | |
| 13 //! data pipes, and shared buffers. Typed handles wrap untyped handles | |
| 14 //! but act much the same as untyped handles. | |
| 15 | |
| 16 use system::ffi; | |
| 17 // This full import is intentional; nearly every type in mojo_types needs to be
used. | |
| 18 use system::mojo_types::*; | |
| 19 | |
| 20 /// The CastHandle trait defines an interface to convert between | |
| 21 /// typed and untyped handles. These are only used internally for | |
| 22 /// typed handles. | |
| 23 pub trait CastHandle { | |
| 24 /// Passes an ownership of an untyped handle and produces a | |
| 25 /// typed handle which owns that untyped handle | |
| 26 /// | |
| 27 /// Casting to a typed handle is unsafe because the handle may | |
| 28 /// not necessarily be a handle to the typed primitive being | |
| 29 /// casted to internally in Mojo | |
| 30 unsafe fn from_untyped(handle: UntypedHandle) -> Self; | |
| 31 | |
| 32 /// Consumes a typed handle and releases ownership of the | |
| 33 /// untyped handle it owned | |
| 34 fn as_untyped(self) -> UntypedHandle; | |
| 35 } | |
| 36 | |
| 37 /// The Handle trait simply means that we can extract | |
| 38 /// the native integer-based Mojo handle from the typed handle. | |
| 39 pub trait Handle { | |
| 40 /// Returns the native handle wrapped by whatever structure | |
| 41 /// implements this trait. | |
| 42 fn get_native_handle(&self) -> MojoHandle; | |
| 43 | |
| 44 /// Waits on the handle wrapped in the current struct until the signals | |
| 45 /// declared in 'signals' are triggered, waiting for a maximum time of | |
| 46 /// 'deadline'. This method blocks. | |
| 47 /// | |
| 48 /// Returns the satisfied and satisfiable signals respectively for this | |
| 49 /// handle when waiting is done. | |
| 50 fn wait(&self, signals: HandleSignals, deadline: MojoDeadline) -> (SignalsSt
ate, MojoResult) { | |
| 51 let mut state: SignalsState = Default::default(); | |
| 52 let r = unsafe { | |
| 53 ffi::MojoWait(self.get_native_handle(), | |
| 54 signals, | |
| 55 deadline, | |
| 56 &mut state as *mut SignalsState) | |
| 57 }; | |
| 58 (state, MojoResult::from_code(r)) | |
| 59 } | |
| 60 } | |
| 61 | |
| 62 /// The basic untyped handle that wraps a MojoHandle (a u32) | |
| 63 pub struct UntypedHandle { | |
| 64 /// The native Mojo handle | |
| 65 value: MojoHandle, | |
| 66 } | |
| 67 | |
| 68 impl UntypedHandle { | |
| 69 /// Invalidates the Handle by setting its native handle to | |
| 70 /// zero, the canonical invalid handle in Mojo. | |
| 71 /// | |
| 72 /// This function is unsafe because clearing a native handle | |
| 73 /// without closing it is a resource leak. | |
| 74 pub unsafe fn invalidate(&mut self) { | |
| 75 self.value = 0 | |
| 76 } | |
| 77 | |
| 78 /// Checks if the native handle is valid (0 = canonical invalid handle). | |
| 79 pub fn is_valid(&self) -> bool { | |
| 80 self.value != 0 | |
| 81 } | |
| 82 } | |
| 83 | |
| 84 impl Handle for UntypedHandle { | |
| 85 /// Pulls out a copy of the native handle wrapped by this structure. | |
| 86 fn get_native_handle(&self) -> MojoHandle { | |
| 87 self.value | |
| 88 } | |
| 89 } | |
| 90 | |
| 91 impl CastHandle for UntypedHandle { | |
| 92 /// Casting an untyped handle is a no-op, but we include | |
| 93 /// this to eliminate code duplication. | |
| 94 unsafe fn from_untyped(handle: UntypedHandle) -> Self { | |
| 95 handle | |
| 96 } | |
| 97 | |
| 98 /// Casting to an untyped handle is a no-op, but we include | |
| 99 /// this to eliminate code duplication. | |
| 100 fn as_untyped(self) -> UntypedHandle { | |
| 101 self | |
| 102 } | |
| 103 } | |
| 104 | |
| 105 impl Drop for UntypedHandle { | |
| 106 /// The destructor for an untyped handle which closes the native handle | |
| 107 /// it wraps. | |
| 108 fn drop(&mut self) { | |
| 109 if self.is_valid() { | |
| 110 let result = MojoResult::from_code(unsafe { ffi::MojoClose(self.get_
native_handle()) }); | |
| 111 if result != MojoResult::Okay { | |
| 112 panic!("Failed to close handle! Reason: {}", result); | |
| 113 } | |
| 114 } | |
| 115 } | |
| 116 } | |
| 117 | |
| 118 /// Acquires a native handle by wrapping it in an untyped handle, allowing | |
| 119 /// us to track the resource and free it appropriately | |
| 120 pub unsafe fn acquire(handle: MojoHandle) -> UntypedHandle { | |
| 121 UntypedHandle { value: handle } | |
| 122 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2250183003:
Make the fuchsia mojo/public repo the source of truth. (Closed)
Base URL: https://github.com/domokit/mojo.git@master