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

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

Index: mojo/public/rust/src/system/shared_buffer.rs
diff --git a/mojo/public/rust/src/system/shared_buffer.rs b/mojo/public/rust/src/system/shared_buffer.rs
deleted file mode 100644
index 399b515c3557159e32c3ca2f135ac4bceeff4626..0000000000000000000000000000000000000000
--- a/mojo/public/rust/src/system/shared_buffer.rs
+++ /dev/null
@@ -1,238 +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.
-
-use std::mem;
-use std::slice;
-use std::ptr;
-
-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;
-use system::handle::{CastHandle, Handle};
-
-#[repr(u32)]
-/// Create flags for shared buffers
-pub enum Create {
-    None = 0,
-}
-
-#[repr(u32)]
-/// Duplicate flags for shared buffers
-pub enum Duplicate {
-    None = 0,
-}
-
-#[repr(u32)]
-/// Map flags for shared buffers
-pub enum Map {
-    None = 0,
-}
-
-#[repr(u32)]
-/// Map flags for shared buffers
-pub enum Info {
-    None = 0,
-}
-
-/// A MappedBuffer represents the result of
-/// calling map_buffer on a shared buffer handle.
-///
-/// The C API allocates a buffer which can then be
-/// read or written to through this data structure.
-///
-/// The importance of this data structure is that
-/// we bind the lifetime of the slice given to us
-/// from the C API to this structure. Additionally,
-/// reads and writes to this data structure are guaranteed
-/// to be able to propagate through Mojo as they are
-/// volatile. Language optimization backends are generally
-/// unaware of other address spaces, and since this structure
-/// represents some buffer from another address space, we
-/// need to make sure loads and stores are volatile.
-///
-/// Changes to this data structure are propagated through Mojo
-/// on the next Mojo operation (that is, Mojo operations are
-/// considered barriers). So, unmapping the buffer, sending a
-/// message across a pipe, duplicating a shared buffer handle,
-/// etc. are all valid ways of propagating changes. The read
-/// and write methods do NOT guarantee changes to propagate.
-///
-/// This structure also prevents resource leaks by
-/// unmapping the buffer it contains on destruction.
-pub struct MappedBuffer<'a> {
-    buffer: &'a mut [u8],
-}
-
-impl<'a> MappedBuffer<'a> {
-    /// Returns the length of the wrapped buffer.
-    ///
-    /// Part of reimplementing the array interface to be
-    /// able to use the structure naturally.
-    pub fn len(&self) -> usize {
-        self.buffer.len()
-    }
-
-    /// Read safely from the shared buffer. Makes sure a real load
-    /// is performed by marking the read as volatile.
-    pub fn read(&self, index: usize) -> u8 {
-        unsafe { ptr::read_volatile((&self.buffer[index]) as *const u8) }
-    }
-
-    /// Write safely to the shared buffer. Makes sure a real store
-    /// is performed by marking the store as volatile.
-    pub fn write(&mut self, index: usize, value: u8) {
-        unsafe {
-            ptr::write_volatile((&mut self.buffer[index]) as *mut u8, value);
-        }
-    }
-
-    /// Returns the slice this buffer wraps.
-    ///
-    /// The reason this method is unsafe is because the way Rust maps
-    /// reads and writes down to loads and stores may not be to real
-    /// loads and stores which are required to allow changes to propagate
-    /// through Mojo. If you are not careful, some writes and reads may be
-    /// to incorrect data! Use at your own risk.
-    pub unsafe fn as_slice(&'a mut self) -> &'a mut [u8] {
-        self.buffer
-    }
-}
-
-impl<'a> Drop for MappedBuffer<'a> {
-    /// The destructor for MappedBuffer. Unmaps the buffer it
-    /// encloses by using the original, raw pointer to the mapped
-    /// memory region.
-    fn drop(&mut self) {
-        let r = MojoResult::from_code(unsafe {
-            ffi::MojoUnmapBuffer(self.buffer.as_ptr() as *const ffi::c_void)
-        });
-        if r != MojoResult::Okay {
-            panic!("Failed to unmap buffer. Mojo Error: {}", r);
-        }
-    }
-}
-
-/// Creates a shared buffer in Mojo and returns a SharedBuffer
-/// structure which represents a handle to the shared buffer.
-pub fn create(flags: CreateFlags, num_bytes: u64) -> Result<SharedBuffer, MojoResult> {
-    let opts = ffi::MojoCreateSharedBufferOptions {
-        struct_size: mem::size_of::<ffi::MojoCreateSharedBufferOptions>() as u32,
-        flags: flags,
-        _align: [],
-    };
-    let raw_opts = &opts as *const ffi::MojoCreateSharedBufferOptions;
-    let mut h: MojoHandle = 0;
-    let r = MojoResult::from_code(unsafe {
-        ffi::MojoCreateSharedBuffer(raw_opts, num_bytes, &mut h as *mut MojoHandle)
-    });
-    if r != MojoResult::Okay {
-        Err(r)
-    } else {
-        Ok(SharedBuffer { handle: unsafe { handle::acquire(h) } })
-    }
-}
-
-/// Represents a handle to a shared buffer in Mojo.
-/// This data structure wraps a handle and acts
-/// effectively as a typed handle.
-pub struct SharedBuffer {
-    handle: handle::UntypedHandle,
-}
-
-impl SharedBuffer {
-    /// Duplicates the shared buffer handle. This is NOT the same
-    /// as cloning the structure which is illegal since cloning could
-    /// lead to resource leaks. Instead this uses Mojo to duplicate the
-    /// buffer handle (though the handle itself may not be represented by
-    /// the same number) that maps to the same shared buffer as the original.
-    pub fn duplicate(&self, flags: DuplicateFlags) -> Result<SharedBuffer, MojoResult> {
-        let opts = ffi::MojoDuplicateBufferHandleOptions {
-            struct_size: mem::size_of::<ffi::MojoDuplicateBufferHandleOptions>() as u32,
-            flags: flags,
-            _align: [],
-        };
-        let raw_opts = &opts as *const ffi::MojoDuplicateBufferHandleOptions;
-        let mut dup_h: MojoHandle = 0;
-        let r = MojoResult::from_code(unsafe {
-            ffi::MojoDuplicateBufferHandle(self.handle.get_native_handle(),
-                                           raw_opts,
-                                           &mut dup_h as *mut MojoHandle)
-        });
-        if r != MojoResult::Okay {
-            Err(r)
-        } else {
-            Ok(SharedBuffer { handle: unsafe { handle::acquire(dup_h) } })
-        }
-    }
-
-    /// Map the shared buffer into local memory. Generates a MappedBuffer
-    /// structure. See MappedBuffer for more information on how to use it.
-    pub fn map<'a>(&self,
-                   offset: u64,
-                   num_bytes: u64,
-                   flags: MapFlags)
-                   -> Result<MappedBuffer<'a>, MojoResult> {
-        unsafe {
-            let mut ptr: *mut ffi::c_void = mem::uninitialized();
-            let r = MojoResult::from_code(ffi::MojoMapBuffer(self.handle.get_native_handle(),
-                                                             offset,
-                                                             num_bytes,
-                                                             &mut ptr,
-                                                             flags));
-            if r != MojoResult::Okay {
-                Err(r)
-            } else {
-                let mut buf = slice::from_raw_parts_mut(ptr as *mut u8, num_bytes as usize);
-                Ok(MappedBuffer { buffer: buf })
-            }
-        }
-    }
-
-    /// Retrieves information about a shared buffer the this handle. The return
-    /// value is a set of flags (a bit vector in a u32) representing different
-    /// aspects of the shared buffer and the size of the shared buffer.
-    pub fn get_info(&self) -> Result<(InfoFlags, u64), MojoResult> {
-        let info_size = mem::size_of::<ffi::MojoBufferInformation>() as u32;
-        let mut info = ffi::MojoBufferInformation {
-            struct_size: info_size,
-            flags: 0,
-            num_bytes: 0,
-            _align: [],
-        };
-        let r = MojoResult::from_code(unsafe {
-            ffi::MojoGetBufferInformation(self.handle.get_native_handle(),
-                                          &mut info as *mut ffi::MojoBufferInformation,
-                                          info_size)
-        });
-        if r != MojoResult::Okay {
-            Err(r)
-        } else {
-            Ok((info.flags, info.num_bytes))
-        }
-    }
-}
-
-impl CastHandle for SharedBuffer {
-    /// Generates a SharedBuffer from an untyped handle wrapper
-    /// See mojo::system::handle for information on untyped vs. typed
-    unsafe fn from_untyped(handle: handle::UntypedHandle) -> Self {
-        SharedBuffer { handle: handle }
-    }
-
-    /// Consumes this object and produces a plain handle wrapper
-    /// See mojo::system::handle for information on untyped vs. typed
-    fn as_untyped(self) -> handle::UntypedHandle {
-        self.handle
-    }
-}
-
-impl Handle for SharedBuffer {
-    /// Returns the native handle wrapped by this structure.
-    ///
-    /// See mojo::system::handle for information on handle wrappers
-    fn get_native_handle(&self) -> MojoHandle {
-        self.handle.get_native_handle()
-    }
-}