Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 738 insertions, 0 deletions

diff --git a/third_party/rust/cubeb-backend/src/capi.rs b/third_party/rust/cubeb-backend/src/capi.rs
new file mode 100644
index 0000000000..a882420c88
--- /dev/null
+++ b/third_party/rust/cubeb-backend/src/capi.rs
@@ -0,0 +1,420 @@
+// Copyright © 2017 Mozilla Foundation
+//
+// This program is made available under an ISC-style license.  See the
+// accompanying file LICENSE for details
+
+use cubeb_core::{ffi, DeviceCollectionRef, DeviceRef, DeviceType, StreamParams, StreamParamsRef};
+use std::ffi::CStr;
+use std::mem;
+use std::os::raw::{c_char, c_int, c_void};
+use {ContextOps, StreamOps};
+
+// Helper macro for unwrapping `Result` values from rust-api calls
+// while returning early with a c-api error code if the value of the
+// expression is `Err`.
+macro_rules! _try(
+    ($e:expr) => (match $e {
+        Ok(e) => e,
+        Err(e) => return e.raw_code()
+    })
+);
+
+macro_rules! as_opt_ref {
+    ($e:expr) => {
+        if $e.is_null() {
+            None
+        } else {
+            Some(StreamParamsRef::from_ptr($e))
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! capi_new(
+    ($ctx:ident, $stm:ident) => (
+        Ops {
+            init: Some($crate::capi::capi_init::<$ctx>),
+            get_backend_id: Some($crate::capi::capi_get_backend_id::<$ctx>),
+            get_max_channel_count: Some($crate::capi::capi_get_max_channel_count::<$ctx>),
+            get_min_latency: Some($crate::capi::capi_get_min_latency::<$ctx>),
+            get_preferred_sample_rate: Some($crate::capi::capi_get_preferred_sample_rate::<$ctx>),
+            enumerate_devices: Some($crate::capi::capi_enumerate_devices::<$ctx>),
+            device_collection_destroy: Some($crate::capi::capi_device_collection_destroy::<$ctx>),
+            destroy: Some($crate::capi::capi_destroy::<$ctx>),
+            stream_init: Some($crate::capi::capi_stream_init::<$ctx>),
+            stream_destroy: Some($crate::capi::capi_stream_destroy::<$stm>),
+            stream_start: Some($crate::capi::capi_stream_start::<$stm>),
+            stream_stop: Some($crate::capi::capi_stream_stop::<$stm>),
+            stream_get_position: Some($crate::capi::capi_stream_get_position::<$stm>),
+            stream_get_latency: Some($crate::capi::capi_stream_get_latency::<$stm>),
+            stream_get_input_latency: Some($crate::capi::capi_stream_get_input_latency::<$stm>),
+            stream_set_volume: Some($crate::capi::capi_stream_set_volume::<$stm>),
+            stream_set_name: Some($crate::capi::capi_stream_set_name::<$stm>),
+            stream_get_current_device: Some($crate::capi::capi_stream_get_current_device::<$stm>),
+            stream_device_destroy: Some($crate::capi::capi_stream_device_destroy::<$stm>),
+            stream_register_device_changed_callback:
+                Some($crate::capi::capi_stream_register_device_changed_callback::<$stm>),
+            register_device_collection_changed:
+                Some($crate::capi::capi_register_device_collection_changed::<$ctx>)
+        }));
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `c` and `context` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_init<CTX: ContextOps>(
+    c: *mut *mut ffi::cubeb,
+    context_name: *const c_char,
+) -> c_int {
+    let anchor = &();
+    let context_name = opt_cstr(anchor, context_name);
+    let context = _try!(CTX::init(context_name));
+    *c = context.as_ptr();
+    // Leaking pointer across C FFI
+    mem::forget(context);
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `c` pointer.
+/// The caller should ensure that pointer is valid.
+pub unsafe extern "C" fn capi_get_backend_id<CTX: ContextOps>(c: *mut ffi::cubeb) -> *const c_char {
+    let ctx = &mut *(c as *mut CTX);
+    ctx.backend_id().as_ptr()
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `c` and `max_channels` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_get_max_channel_count<CTX: ContextOps>(
+    c: *mut ffi::cubeb,
+    max_channels: *mut u32,
+) -> c_int {
+    let ctx = &mut *(c as *mut CTX);
+
+    *max_channels = _try!(ctx.max_channel_count());
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `c` and `latency_frames` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_get_min_latency<CTX: ContextOps>(
+    c: *mut ffi::cubeb,
+    param: ffi::cubeb_stream_params,
+    latency_frames: *mut u32,
+) -> c_int {
+    let ctx = &mut *(c as *mut CTX);
+    let param = StreamParams::from(param);
+    *latency_frames = _try!(ctx.min_latency(param));
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `c` and `rate` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_get_preferred_sample_rate<CTX: ContextOps>(
+    c: *mut ffi::cubeb,
+    rate: *mut u32,
+) -> c_int {
+    let ctx = &mut *(c as *mut CTX);
+
+    *rate = _try!(ctx.preferred_sample_rate());
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `c` and `collection` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_enumerate_devices<CTX: ContextOps>(
+    c: *mut ffi::cubeb,
+    devtype: ffi::cubeb_device_type,
+    collection: *mut ffi::cubeb_device_collection,
+) -> c_int {
+    let ctx = &mut *(c as *mut CTX);
+    let devtype = DeviceType::from_bits_truncate(devtype);
+    let collection = DeviceCollectionRef::from_ptr(collection);
+    _try!(ctx.enumerate_devices(devtype, collection));
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `c` and `collection` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_device_collection_destroy<CTX: ContextOps>(
+    c: *mut ffi::cubeb,
+    collection: *mut ffi::cubeb_device_collection,
+) -> c_int {
+    let ctx = &mut *(c as *mut CTX);
+    let collection = DeviceCollectionRef::from_ptr_mut(collection);
+    _try!(ctx.device_collection_destroy(collection));
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `c` pointer.
+/// The caller should ensure that pointer is valid.
+pub unsafe extern "C" fn capi_destroy<CTX>(c: *mut ffi::cubeb) {
+    let _: Box<CTX> = Box::from_raw(c as *mut _);
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `c`, `s`, `stream_name`, `input_stream_params`,
+/// `output_stream_params`, `data_callback`, `state_callback`, and `user_ptr` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_stream_init<CTX: ContextOps>(
+    c: *mut ffi::cubeb,
+    s: *mut *mut ffi::cubeb_stream,
+    stream_name: *const c_char,
+    input_device: ffi::cubeb_devid,
+    input_stream_params: *mut ffi::cubeb_stream_params,
+    output_device: ffi::cubeb_devid,
+    output_stream_params: *mut ffi::cubeb_stream_params,
+    latency_frames: u32,
+    data_callback: ffi::cubeb_data_callback,
+    state_callback: ffi::cubeb_state_callback,
+    user_ptr: *mut c_void,
+) -> c_int {
+    let ctx = &mut *(c as *mut CTX);
+    let anchor = &(); // for lifetime of stream_name as CStr
+
+    let input_stream_params = as_opt_ref!(input_stream_params);
+    let output_stream_params = as_opt_ref!(output_stream_params);
+
+    let stream = _try!(ctx.stream_init(
+        opt_cstr(anchor, stream_name),
+        input_device,
+        input_stream_params,
+        output_device,
+        output_stream_params,
+        latency_frames,
+        data_callback,
+        state_callback,
+        user_ptr
+    ));
+    *s = stream.as_ptr();
+    // Leaking pointer across C FFI
+    mem::forget(stream);
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` pointer.
+/// The caller should ensure that pointer is valid.
+pub unsafe extern "C" fn capi_stream_destroy<STM>(s: *mut ffi::cubeb_stream) {
+    let _ = Box::from_raw(s as *mut STM);
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` pointer.
+/// The caller should ensure that pointer is valid.
+pub unsafe extern "C" fn capi_stream_start<STM: StreamOps>(s: *mut ffi::cubeb_stream) -> c_int {
+    let stm = &mut *(s as *mut STM);
+
+    _try!(stm.start());
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` pointer.
+/// The caller should ensure that pointer is valid.
+pub unsafe extern "C" fn capi_stream_stop<STM: StreamOps>(s: *mut ffi::cubeb_stream) -> c_int {
+    let stm = &mut *(s as *mut STM);
+
+    _try!(stm.stop());
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` and `position` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_stream_get_position<STM: StreamOps>(
+    s: *mut ffi::cubeb_stream,
+    position: *mut u64,
+) -> c_int {
+    let stm = &mut *(s as *mut STM);
+
+    *position = _try!(stm.position());
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` and `latency` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_stream_get_latency<STM: StreamOps>(
+    s: *mut ffi::cubeb_stream,
+    latency: *mut u32,
+) -> c_int {
+    let stm = &mut *(s as *mut STM);
+
+    *latency = _try!(stm.latency());
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` and `latency` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_stream_get_input_latency<STM: StreamOps>(
+    s: *mut ffi::cubeb_stream,
+    latency: *mut u32,
+) -> c_int {
+    let stm = &mut *(s as *mut STM);
+
+    *latency = _try!(stm.input_latency());
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` pointer.
+/// The caller should ensure that pointer is valid.
+pub unsafe extern "C" fn capi_stream_set_volume<STM: StreamOps>(
+    s: *mut ffi::cubeb_stream,
+    volume: f32,
+) -> c_int {
+    let stm = &mut *(s as *mut STM);
+
+    _try!(stm.set_volume(volume));
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` and `name` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_stream_set_name<STM: StreamOps>(
+    s: *mut ffi::cubeb_stream,
+    name: *const c_char,
+) -> c_int {
+    let stm = &mut *(s as *mut STM);
+    let anchor = &();
+    if let Some(name) = opt_cstr(anchor, name) {
+        _try!(stm.set_name(name));
+        ffi::CUBEB_OK
+    } else {
+        ffi::CUBEB_ERROR_INVALID_PARAMETER
+    }
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` and `device` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_stream_get_current_device<STM: StreamOps>(
+    s: *mut ffi::cubeb_stream,
+    device: *mut *mut ffi::cubeb_device,
+) -> i32 {
+    let stm = &mut *(s as *mut STM);
+
+    *device = _try!(stm.current_device()).as_ptr();
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` and `device` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_stream_device_destroy<STM: StreamOps>(
+    s: *mut ffi::cubeb_stream,
+    device: *mut ffi::cubeb_device,
+) -> c_int {
+    let stm = &mut *(s as *mut STM);
+    let device = DeviceRef::from_ptr(device);
+    let _ = stm.device_destroy(device);
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` and `device_changed_callback` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_stream_register_device_changed_callback<STM: StreamOps>(
+    s: *mut ffi::cubeb_stream,
+    device_changed_callback: ffi::cubeb_device_changed_callback,
+) -> c_int {
+    let stm = &mut *(s as *mut STM);
+
+    _try!(stm.register_device_changed_callback(device_changed_callback));
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s`, `collection_changed_callback`, and
+/// `user_ptr` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_register_device_collection_changed<CTX: ContextOps>(
+    c: *mut ffi::cubeb,
+    devtype: ffi::cubeb_device_type,
+    collection_changed_callback: ffi::cubeb_device_collection_changed_callback,
+    user_ptr: *mut c_void,
+) -> i32 {
+    let ctx = &mut *(c as *mut CTX);
+    let devtype = DeviceType::from_bits_truncate(devtype);
+    _try!(ctx.register_device_collection_changed(devtype, collection_changed_callback, user_ptr));
+    ffi::CUBEB_OK
+}
+
+fn opt_cstr<T>(_anchor: &T, ptr: *const c_char) -> Option<&CStr> {
+    if ptr.is_null() {
+        None
+    } else {
+        Some(unsafe { CStr::from_ptr(ptr) })
+    }
+}
diff --git a/third_party/rust/cubeb-backend/src/lib.rs b/third_party/rust/cubeb-backend/src/lib.rs
new file mode 100644
index 0000000000..5b943e89c3
--- /dev/null
+++ b/third_party/rust/cubeb-backend/src/lib.rs
@@ -0,0 +1,17 @@
+// Copyright © 2017 Mozilla Foundation
+//
+// This program is made available under an ISC-style license.  See the
+// accompanying file LICENSE for details.
+
+extern crate cubeb_core;
+
+pub mod capi;
+#[macro_use]
+pub mod log;
+mod ops;
+mod traits;
+
+// Re-export cubeb_core types
+pub use cubeb_core::*;
+pub use ops::Ops;
+pub use traits::{ContextOps, StreamOps};
diff --git a/third_party/rust/cubeb-backend/src/log.rs b/third_party/rust/cubeb-backend/src/log.rs
new file mode 100644
index 0000000000..c03d6b81be
--- /dev/null
+++ b/third_party/rust/cubeb-backend/src/log.rs
@@ -0,0 +1,143 @@
+// Copyright © 2017-2018 Mozilla Foundation
+//
+// This program is made available under an ISC-style license.  See the
+// accompanying file LICENSE for details.
+
+use std::os::raw::c_char;
+
+/// Maximum length in bytes for a log message.
+/// Longer messages are silently truncated.  See `write_str`.
+const LOG_LIMIT: usize = 1024;
+
+struct StaticCString<const N: usize> {
+    buf: [std::mem::MaybeUninit<u8>; N],
+    len: usize,
+}
+
+impl<const N: usize> StaticCString<N> {
+    fn new() -> Self {
+        StaticCString {
+            buf: unsafe { std::mem::MaybeUninit::uninit().assume_init() },
+            len: 0,
+        }
+    }
+
+    fn as_cstr(&self) -> &std::ffi::CStr {
+        unsafe {
+            std::ffi::CStr::from_bytes_with_nul_unchecked(std::slice::from_raw_parts(
+                self.buf.as_ptr().cast::<u8>(),
+                self.len,
+            ))
+        }
+    }
+}
+
+impl<const N: usize> std::fmt::Write for StaticCString<N> {
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        use std::convert::TryInto;
+        let s = s.as_bytes();
+        let end = s.len().min(N.checked_sub(1).unwrap() - self.len);
+        debug_assert_eq!(s.len(), end, "message truncated");
+        unsafe {
+            std::ptr::copy_nonoverlapping(
+                s[..end].as_ptr(),
+                self.buf
+                    .as_mut_ptr()
+                    .cast::<u8>()
+                    .offset(self.len.try_into().unwrap()),
+                end,
+            )
+        };
+        self.len += end;
+        self.buf[self.len].write(0);
+        Ok(())
+    }
+}
+
+/// Formats `$file:line: $msg\n` into an on-stack buffer of size `LOG_LIMIT`,
+/// then calls `log_callback` with a pointer to the formatted message.
+pub fn cubeb_log_internal_buf_fmt(
+    log_callback: unsafe extern "C" fn(*const c_char, ...),
+    file: &str,
+    line: u32,
+    msg: std::fmt::Arguments,
+) {
+    let filename = std::path::Path::new(file)
+        .file_name()
+        .unwrap()
+        .to_str()
+        .unwrap();
+    let mut buf = StaticCString::<LOG_LIMIT>::new();
+    let _ = std::fmt::write(&mut buf, format_args!("{}:{}: {}\n", filename, line, msg));
+    unsafe {
+        log_callback(buf.as_cstr().as_ptr());
+    };
+}
+
+#[macro_export]
+macro_rules! cubeb_log_internal {
+    ($log_callback: expr, $level: expr, $fmt: expr, $($arg: expr),+) => {
+        #[allow(unused_unsafe)]
+        unsafe {
+            if $level <= $crate::ffi::cubeb_log_get_level().into() {
+                if let Some(log_callback) = $log_callback {
+                    $crate::log::cubeb_log_internal_buf_fmt(log_callback, file!(), line!(), format_args!($fmt, $($arg),+));
+                }
+            }
+        }
+    };
+    ($log_callback: expr, $level: expr, $msg: expr) => {
+        cubeb_log_internal!($log_callback, $level, "{}", $msg);
+    };
+}
+
+#[macro_export]
+macro_rules! cubeb_log {
+    ($($arg: expr),+) => (cubeb_log_internal!($crate::ffi::cubeb_log_get_callback(), $crate::LogLevel::Normal, $($arg),+));
+}
+
+#[macro_export]
+macro_rules! cubeb_logv {
+    ($($arg: expr),+) => (cubeb_log_internal!($crate::ffi::cubeb_log_get_callback(), $crate::LogLevel::Verbose, $($arg),+));
+}
+
+#[macro_export]
+macro_rules! cubeb_alog {
+    ($($arg: expr),+) => (cubeb_log_internal!($crate::ffi::cubeb_async_log.into(), $crate::LogLevel::Normal, $($arg),+));
+}
+
+#[macro_export]
+macro_rules! cubeb_alogv {
+    ($($arg: expr),+) => (cubeb_log_internal!($crate::ffi::cubeb_async_log.into(), $crate::LogLevel::Verbose, $($arg),+));
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_normal_logging_sync() {
+        cubeb_log!("This is synchronous log output at normal level");
+        cubeb_log!("{} Formatted log", 1);
+        cubeb_log!("{} Formatted {} log {}", 1, 2, 3);
+    }
+
+    #[test]
+    fn test_verbose_logging_sync() {
+        cubeb_logv!("This is synchronous log output at verbose level");
+        cubeb_logv!("{} Formatted log", 1);
+        cubeb_logv!("{} Formatted {} log {}", 1, 2, 3);
+    }
+
+    #[test]
+    fn test_normal_logging_async() {
+        cubeb_alog!("This is asynchronous log output at normal level");
+        cubeb_alog!("{} Formatted log", 1);
+        cubeb_alog!("{} Formatted {} log {}", 1, 2, 3);
+    }
+
+    #[test]
+    fn test_verbose_logging_async() {
+        cubeb_alogv!("This is asynchronous log output at verbose level");
+        cubeb_alogv!("{} Formatted log", 1);
+        cubeb_alogv!("{} Formatted {} log {}", 1, 2, 3);
+    }
+}
diff --git a/third_party/rust/cubeb-backend/src/ops.rs b/third_party/rust/cubeb-backend/src/ops.rs
new file mode 100644
index 0000000000..0c53d44e9d
--- /dev/null
+++ b/third_party/rust/cubeb-backend/src/ops.rs
@@ -0,0 +1,97 @@
+// Copyright © 2017 Mozilla Foundation
+//
+// This program is made available under an ISC-style license.  See the
+// accompanying file LICENSE for details.
+
+#![allow(non_camel_case_types)]
+
+use ffi;
+use std::os::raw::{c_char, c_float, c_int, c_uint, c_void};
+
+#[repr(C)]
+pub struct Ops {
+    pub init: Option<
+        unsafe extern "C" fn(context: *mut *mut ffi::cubeb, context_name: *const c_char) -> c_int,
+    >,
+    pub get_backend_id: Option<unsafe extern "C" fn(context: *mut ffi::cubeb) -> *const c_char>,
+    pub get_max_channel_count:
+        Option<unsafe extern "C" fn(context: *mut ffi::cubeb, max_channels: *mut c_uint) -> c_int>,
+    pub get_min_latency: Option<
+        unsafe extern "C" fn(
+            context: *mut ffi::cubeb,
+            params: ffi::cubeb_stream_params,
+            latency_ms: *mut c_uint,
+        ) -> c_int,
+    >,
+    pub get_preferred_sample_rate:
+        Option<unsafe extern "C" fn(context: *mut ffi::cubeb, rate: *mut u32) -> c_int>,
+    pub enumerate_devices: Option<
+        unsafe extern "C" fn(
+            context: *mut ffi::cubeb,
+            devtype: ffi::cubeb_device_type,
+            collection: *mut ffi::cubeb_device_collection,
+        ) -> c_int,
+    >,
+    pub device_collection_destroy: Option<
+        unsafe extern "C" fn(
+            context: *mut ffi::cubeb,
+            collection: *mut ffi::cubeb_device_collection,
+        ) -> c_int,
+    >,
+    pub destroy: Option<unsafe extern "C" fn(context: *mut ffi::cubeb)>,
+    #[allow(clippy::type_complexity)]
+    pub stream_init: Option<
+        unsafe extern "C" fn(
+            context: *mut ffi::cubeb,
+            stream: *mut *mut ffi::cubeb_stream,
+            stream_name: *const c_char,
+            input_device: ffi::cubeb_devid,
+            input_stream_params: *mut ffi::cubeb_stream_params,
+            output_device: ffi::cubeb_devid,
+            output_stream_params: *mut ffi::cubeb_stream_params,
+            latency: c_uint,
+            data_callback: ffi::cubeb_data_callback,
+            state_callback: ffi::cubeb_state_callback,
+            user_ptr: *mut c_void,
+        ) -> c_int,
+    >,
+    pub stream_destroy: Option<unsafe extern "C" fn(stream: *mut ffi::cubeb_stream)>,
+    pub stream_start: Option<unsafe extern "C" fn(stream: *mut ffi::cubeb_stream) -> c_int>,
+    pub stream_stop: Option<unsafe extern "C" fn(stream: *mut ffi::cubeb_stream) -> c_int>,
+    pub stream_get_position:
+        Option<unsafe extern "C" fn(stream: *mut ffi::cubeb_stream, position: *mut u64) -> c_int>,
+    pub stream_get_latency:
+        Option<unsafe extern "C" fn(stream: *mut ffi::cubeb_stream, latency: *mut u32) -> c_int>,
+    pub stream_get_input_latency:
+        Option<unsafe extern "C" fn(stream: *mut ffi::cubeb_stream, latency: *mut u32) -> c_int>,
+    pub stream_set_volume:
+        Option<unsafe extern "C" fn(stream: *mut ffi::cubeb_stream, volumes: c_float) -> c_int>,
+    pub stream_set_name:
+        Option<unsafe extern "C" fn(stream: *mut ffi::cubeb_stream, name: *const c_char) -> c_int>,
+    pub stream_get_current_device: Option<
+        unsafe extern "C" fn(
+            stream: *mut ffi::cubeb_stream,
+            device: *mut *mut ffi::cubeb_device,
+        ) -> c_int,
+    >,
+    pub stream_device_destroy: Option<
+        unsafe extern "C" fn(
+            stream: *mut ffi::cubeb_stream,
+            device: *mut ffi::cubeb_device,
+        ) -> c_int,
+    >,
+    pub stream_register_device_changed_callback: Option<
+        unsafe extern "C" fn(
+            stream: *mut ffi::cubeb_stream,
+            device_changed_callback: ffi::cubeb_device_changed_callback,
+        ) -> c_int,
+    >,
+    pub register_device_collection_changed: Option<
+        unsafe extern "C" fn(
+            context: *mut ffi::cubeb,
+            devtype: ffi::cubeb_device_type,
+            callback: ffi::cubeb_device_collection_changed_callback,
+            user_ptr: *mut c_void,
+        ) -> c_int,
+    >,
+}
diff --git a/third_party/rust/cubeb-backend/src/traits.rs b/third_party/rust/cubeb-backend/src/traits.rs
new file mode 100644
index 0000000000..c40cf3a7f2
--- /dev/null
+++ b/third_party/rust/cubeb-backend/src/traits.rs
@@ -0,0 +1,61 @@
+// Copyright © 2017 Mozilla Foundation
+//
+// This program is made available under an ISC-style license.  See the
+// accompanying file LICENSE for details.
+
+use cubeb_core::{
+    Context, DeviceCollectionRef, DeviceId, DeviceRef, DeviceType, Result, Stream, StreamParams,
+    StreamParamsRef,
+};
+use ffi;
+use std::ffi::CStr;
+use std::os::raw::c_void;
+
+pub trait ContextOps {
+    fn init(context_name: Option<&CStr>) -> Result<Context>;
+    fn backend_id(&mut self) -> &CStr;
+    fn max_channel_count(&mut self) -> Result<u32>;
+    fn min_latency(&mut self, params: StreamParams) -> Result<u32>;
+    fn preferred_sample_rate(&mut self) -> Result<u32>;
+    fn enumerate_devices(
+        &mut self,
+        devtype: DeviceType,
+        collection: &DeviceCollectionRef,
+    ) -> Result<()>;
+    fn device_collection_destroy(&mut self, collection: &mut DeviceCollectionRef) -> Result<()>;
+    #[cfg_attr(feature = "cargo-clippy", allow(clippy::too_many_arguments))]
+    fn stream_init(
+        &mut self,
+        stream_name: Option<&CStr>,
+        input_device: DeviceId,
+        input_stream_params: Option<&StreamParamsRef>,
+        output_device: DeviceId,
+        output_stream_params: Option<&StreamParamsRef>,
+        latency_frames: u32,
+        data_callback: ffi::cubeb_data_callback,
+        state_callback: ffi::cubeb_state_callback,
+        user_ptr: *mut c_void,
+    ) -> Result<Stream>;
+    fn register_device_collection_changed(
+        &mut self,
+        devtype: DeviceType,
+        cb: ffi::cubeb_device_collection_changed_callback,
+        user_ptr: *mut c_void,
+    ) -> Result<()>;
+}
+
+pub trait StreamOps {
+    fn start(&mut self) -> Result<()>;
+    fn stop(&mut self) -> Result<()>;
+    fn position(&mut self) -> Result<u64>;
+    fn latency(&mut self) -> Result<u32>;
+    fn input_latency(&mut self) -> Result<u32>;
+    fn set_volume(&mut self, volume: f32) -> Result<()>;
+    fn set_name(&mut self, name: &CStr) -> Result<()>;
+    fn current_device(&mut self) -> Result<&DeviceRef>;
+    fn device_destroy(&mut self, device: &DeviceRef) -> Result<()>;
+    fn register_device_changed_callback(
+        &mut self,
+        device_changed_callback: ffi::cubeb_device_changed_callback,
+    ) -> Result<()>;
+}