Adding upstream version 124.0.1.upstream/124.0.1

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

9 files changed, 1152 insertions, 0 deletions

diff --git a/third_party/rust/cubeb-backend/.cargo-checksum.json b/third_party/rust/cubeb-backend/.cargo-checksum.json
new file mode 100644
index 0000000000..b7957cac43
--- /dev/null
+++ b/third_party/rust/cubeb-backend/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"b3a6e03dbc48515bbca791eba64096ab43dddafa6c60eec2b824369e2afb31b8","LICENSE":"8c044baa5d883274736eeece0b955249076c2697b826e576fce59496235b2cf5","src/capi.rs":"d9bc993ea8bb51220c5cdc54488bc795f74411fe688332bd80dbb062c41342bb","src/lib.rs":"4ce6db20f88487e99057ebeae0615fa1c99e82cfee0ab0825936da2e108fc73e","src/log.rs":"968b839a8a5a56fe42e372678fdd580e2777e1dba8c4f0bee6fbfe5e3f03b860","src/ops.rs":"e631eba0d1ef8c13287361be32c0806d7869f598f58266bab0a45642521fa07e","src/traits.rs":"45e3e58772dd0ff40bf36d56dd9f1fc682cc08cea570022fa50eae1c34d43a3a","tests/test_capi.rs":"783c8321dceb33a414168ae64e162f934015144f49118d868557009819a20e06"},"package":"b00b0f3b84e315571bd8c4e18794180633066267a413f2f05bca65001adc8410"}
\ No newline at end of file
diff --git a/third_party/rust/cubeb-backend/Cargo.toml b/third_party/rust/cubeb-backend/Cargo.toml
new file mode 100644
index 0000000000..2f4d2dc055
--- /dev/null
+++ b/third_party/rust/cubeb-backend/Cargo.toml
@@ -0,0 +1,32 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+name = "cubeb-backend"
+version = "0.12.0"
+authors = ["Dan Glastonbury <dglastonbury@mozilla.com>"]
+description = """
+Bindings to libcubeb internals to facilitate implementing cubeb backends in rust.
+"""
+homepage = "https://github.com/mozilla/cubeb-rs"
+keywords = ["cubeb"]
+categories = ["api-bindings"]
+license = "ISC"
+repository = "https://github.com/mozilla/cubeb-rs"
+
+[dependencies.cubeb-core]
+version = "0.12.0"
+
+[features]
+gecko-in-tree = ["cubeb-core/gecko-in-tree"]
+
+[badges.circle-ci]
+repository = "mozilla/cubeb-rs"
diff --git a/third_party/rust/cubeb-backend/LICENSE b/third_party/rust/cubeb-backend/LICENSE
new file mode 100644
index 0000000000..ec9718cf02
--- /dev/null
+++ b/third_party/rust/cubeb-backend/LICENSE
@@ -0,0 +1,13 @@
+Copyright © 2017 Mozilla Foundation
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
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..550c2ce05d
--- /dev/null
+++ b/third_party/rust/cubeb-backend/src/capi.rs
@@ -0,0 +1,473 @@
+// 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, InputProcessingParams, 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>),
+            get_supported_input_processing_params:
+                Some($crate::capi::capi_get_supported_input_processing_params::<$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_set_input_mute: Some($crate::capi::capi_stream_set_input_mute::<$stm>),
+            stream_set_input_processing_params:
+                Some($crate::capi::capi_stream_set_input_processing_params::<$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 `params` pointers.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_get_supported_input_processing_params<CTX: ContextOps>(
+    c: *mut ffi::cubeb,
+    params: *mut ffi::cubeb_input_processing_params,
+) -> c_int {
+    let ctx = &mut *(c as *mut CTX);
+    *params = _try!(ctx.supported_input_processing_params()).bits();
+    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` pointer.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_stream_set_input_mute<STM: StreamOps>(
+    s: *mut ffi::cubeb_stream,
+    mute: c_int,
+) -> c_int {
+    let stm = &mut *(s as *mut STM);
+    _try!(stm.set_input_mute(mute != 0));
+    ffi::CUBEB_OK
+}
+
+/// # Safety
+///
+/// Entry point from C code.
+///
+/// This function is unsafe because it dereferences the given `s` pointer.
+/// The caller should ensure those pointers are valid.
+pub unsafe extern "C" fn capi_stream_set_input_processing_params<STM: StreamOps>(
+    s: *mut ffi::cubeb_stream,
+    params: ffi::cubeb_input_processing_params,
+) -> c_int {
+    let stm = &mut *(s as *mut STM);
+    _try!(stm.set_input_processing_params(InputProcessingParams::from_bits_truncate(params)));
+    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..c819ce6b3b
--- /dev/null
+++ b/third_party/rust/cubeb-backend/src/ops.rs
@@ -0,0 +1,111 @@
+// 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 get_supported_input_processing_params: Option<
+        unsafe extern "C" fn(
+            c: *mut ffi::cubeb,
+            params: *mut ffi::cubeb_input_processing_params,
+        ) -> 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_set_input_mute:
+        Option<unsafe extern "C" fn(stream: *mut ffi::cubeb_stream, mute: c_int) -> c_int>,
+    pub stream_set_input_processing_params: Option<
+        unsafe extern "C" fn(
+            stream: *mut ffi::cubeb_stream,
+            params: ffi::cubeb_input_processing_params,
+        ) -> 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..79488d5772
--- /dev/null
+++ b/third_party/rust/cubeb-backend/src/traits.rs
@@ -0,0 +1,64 @@
+// 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, InputProcessingParams, 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 supported_input_processing_params(&mut self) -> Result<InputProcessingParams>;
+    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 set_input_mute(&mut self, mute: bool) -> Result<()>;
+    fn set_input_processing_params(&mut self, params: InputProcessingParams) -> Result<()>;
+    fn device_destroy(&mut self, device: &DeviceRef) -> Result<()>;
+    fn register_device_changed_callback(
+        &mut self,
+        device_changed_callback: ffi::cubeb_device_changed_callback,
+    ) -> Result<()>;
+}
diff --git a/third_party/rust/cubeb-backend/tests/test_capi.rs b/third_party/rust/cubeb-backend/tests/test_capi.rs
new file mode 100644
index 0000000000..8549f2dc5c
--- /dev/null
+++ b/third_party/rust/cubeb-backend/tests/test_capi.rs
@@ -0,0 +1,298 @@
+// Copyright © 2017 Mozilla Foundation
+//
+// This program is made available under an ISC-style license.  See the
+// accompanying file LICENSE for details
+
+#![cfg_attr(feature = "cargo-clippy", allow(clippy::float_cmp))]
+
+#[macro_use]
+extern crate cubeb_backend;
+
+use cubeb_backend::{
+    ffi, Context, ContextOps, DeviceCollectionRef, DeviceId, DeviceRef, DeviceType,
+    InputProcessingParams, Ops, Result, Stream, StreamOps, StreamParams, StreamParamsRef,
+};
+use std::ffi::CStr;
+use std::os::raw::c_void;
+use std::ptr;
+
+pub const OPS: Ops = capi_new!(TestContext, TestStream);
+
+struct TestContext {
+    #[allow(dead_code)]
+    pub ops: *const Ops,
+}
+
+impl ContextOps for TestContext {
+    fn init(_context_name: Option<&CStr>) -> Result<Context> {
+        let ctx = Box::new(TestContext {
+            ops: &OPS as *const _,
+        });
+        Ok(unsafe { Context::from_ptr(Box::into_raw(ctx) as *mut _) })
+    }
+
+    fn backend_id(&mut self) -> &'static CStr {
+        unsafe { CStr::from_ptr(b"remote\0".as_ptr() as *const _) }
+    }
+    fn max_channel_count(&mut self) -> Result<u32> {
+        Ok(0u32)
+    }
+    fn min_latency(&mut self, _params: StreamParams) -> Result<u32> {
+        Ok(0u32)
+    }
+    fn preferred_sample_rate(&mut self) -> Result<u32> {
+        Ok(0u32)
+    }
+    fn supported_input_processing_params(&mut self) -> Result<InputProcessingParams> {
+        Ok(InputProcessingParams::NONE)
+    }
+    fn enumerate_devices(
+        &mut self,
+        _devtype: DeviceType,
+        collection: &DeviceCollectionRef,
+    ) -> Result<()> {
+        let coll = unsafe { &mut *collection.as_ptr() };
+        coll.device = 0xDEAD_BEEF as *mut _;
+        coll.count = usize::max_value();
+        Ok(())
+    }
+    fn device_collection_destroy(&mut self, collection: &mut DeviceCollectionRef) -> Result<()> {
+        let coll = unsafe { &mut *collection.as_ptr() };
+        assert_eq!(coll.device, 0xDEAD_BEEF as *mut _);
+        assert_eq!(coll.count, usize::max_value());
+        coll.device = ptr::null_mut();
+        coll.count = 0;
+        Ok(())
+    }
+    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_frame: u32,
+        _data_callback: ffi::cubeb_data_callback,
+        _state_callback: ffi::cubeb_state_callback,
+        _user_ptr: *mut c_void,
+    ) -> Result<Stream> {
+        Ok(unsafe { Stream::from_ptr(0xDEAD_BEEF as *mut _) })
+    }
+    fn register_device_collection_changed(
+        &mut self,
+        _dev_type: DeviceType,
+        _collection_changed_callback: ffi::cubeb_device_collection_changed_callback,
+        _user_ptr: *mut c_void,
+    ) -> Result<()> {
+        Ok(())
+    }
+}
+
+struct TestStream {}
+
+impl StreamOps for TestStream {
+    fn start(&mut self) -> Result<()> {
+        Ok(())
+    }
+    fn stop(&mut self) -> Result<()> {
+        Ok(())
+    }
+    fn position(&mut self) -> Result<u64> {
+        Ok(0u64)
+    }
+    fn latency(&mut self) -> Result<u32> {
+        Ok(0u32)
+    }
+    fn input_latency(&mut self) -> Result<u32> {
+        Ok(0u32)
+    }
+    fn set_volume(&mut self, volume: f32) -> Result<()> {
+        assert_eq!(volume, 0.5);
+        Ok(())
+    }
+    fn set_name(&mut self, name: &CStr) -> Result<()> {
+        assert_eq!(name, CStr::from_bytes_with_nul(b"test\0").unwrap());
+        Ok(())
+    }
+    fn current_device(&mut self) -> Result<&DeviceRef> {
+        Ok(unsafe { DeviceRef::from_ptr(0xDEAD_BEEF as *mut _) })
+    }
+    fn set_input_mute(&mut self, mute: bool) -> Result<()> {
+        assert_eq!(mute, true);
+        Ok(())
+    }
+    fn set_input_processing_params(&mut self, params: InputProcessingParams) -> Result<()> {
+        assert_eq!(params, InputProcessingParams::ECHO_CANCELLATION);
+        Ok(())
+    }
+    fn device_destroy(&mut self, device: &DeviceRef) -> Result<()> {
+        assert_eq!(device.as_ptr(), 0xDEAD_BEEF as *mut _);
+        Ok(())
+    }
+    fn register_device_changed_callback(
+        &mut self,
+        _: ffi::cubeb_device_changed_callback,
+    ) -> Result<()> {
+        Ok(())
+    }
+}
+
+#[test]
+fn test_ops_context_init() {
+    let mut c: *mut ffi::cubeb = ptr::null_mut();
+    assert_eq!(
+        unsafe { OPS.init.unwrap()(&mut c, ptr::null()) },
+        ffi::CUBEB_OK
+    );
+    unsafe { OPS.destroy.unwrap()(c) }
+}
+
+#[test]
+fn test_ops_context_max_channel_count() {
+    let c: *mut ffi::cubeb = ptr::null_mut();
+    let mut max_channel_count = u32::max_value();
+    assert_eq!(
+        unsafe { OPS.get_max_channel_count.unwrap()(c, &mut max_channel_count) },
+        ffi::CUBEB_OK
+    );
+    assert_eq!(max_channel_count, 0);
+}
+
+#[test]
+fn test_ops_context_min_latency() {
+    let c: *mut ffi::cubeb = ptr::null_mut();
+    let params: ffi::cubeb_stream_params = unsafe { ::std::mem::zeroed() };
+    let mut latency = u32::max_value();
+    assert_eq!(
+        unsafe { OPS.get_min_latency.unwrap()(c, params, &mut latency) },
+        ffi::CUBEB_OK
+    );
+    assert_eq!(latency, 0);
+}
+
+#[test]
+fn test_ops_context_preferred_sample_rate() {
+    let c: *mut ffi::cubeb = ptr::null_mut();
+    let mut rate = u32::max_value();
+    assert_eq!(
+        unsafe { OPS.get_preferred_sample_rate.unwrap()(c, &mut rate) },
+        ffi::CUBEB_OK
+    );
+    assert_eq!(rate, 0);
+}
+
+#[test]
+fn test_ops_context_supported_input_processing_params() {
+    let c: *mut ffi::cubeb = ptr::null_mut();
+    let mut params: ffi::cubeb_input_processing_params = InputProcessingParams::all().bits();
+    assert_eq!(
+        unsafe { OPS.get_supported_input_processing_params.unwrap()(c, &mut params) },
+        ffi::CUBEB_OK
+    );
+    assert_eq!(params, ffi::CUBEB_INPUT_PROCESSING_PARAM_NONE);
+}
+
+#[test]
+fn test_ops_context_enumerate_devices() {
+    let c: *mut ffi::cubeb = ptr::null_mut();
+    let mut coll = ffi::cubeb_device_collection {
+        device: ptr::null_mut(),
+        count: 0,
+    };
+    assert_eq!(
+        unsafe { OPS.enumerate_devices.unwrap()(c, 0, &mut coll) },
+        ffi::CUBEB_OK
+    );
+    assert_eq!(coll.device, 0xDEAD_BEEF as *mut _);
+    assert_eq!(coll.count, usize::max_value())
+}
+
+#[test]
+fn test_ops_context_device_collection_destroy() {
+    let c: *mut ffi::cubeb = ptr::null_mut();
+    let mut coll = ffi::cubeb_device_collection {
+        device: 0xDEAD_BEEF as *mut _,
+        count: usize::max_value(),
+    };
+    assert_eq!(
+        unsafe { OPS.device_collection_destroy.unwrap()(c, &mut coll) },
+        ffi::CUBEB_OK
+    );
+    assert_eq!(coll.device, ptr::null_mut());
+    assert_eq!(coll.count, 0);
+}
+
+// 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>),
+
+#[test]
+fn test_ops_stream_latency() {
+    let s: *mut ffi::cubeb_stream = ptr::null_mut();
+    let mut latency = u32::max_value();
+    assert_eq!(
+        unsafe { OPS.stream_get_latency.unwrap()(s, &mut latency) },
+        ffi::CUBEB_OK
+    );
+    assert_eq!(latency, 0);
+}
+
+#[test]
+fn test_ops_stream_set_volume() {
+    let s: *mut ffi::cubeb_stream = ptr::null_mut();
+    unsafe {
+        OPS.stream_set_volume.unwrap()(s, 0.5);
+    }
+}
+
+#[test]
+fn test_ops_stream_set_name() {
+    let s: *mut ffi::cubeb_stream = ptr::null_mut();
+    unsafe {
+        OPS.stream_set_name.unwrap()(s, CStr::from_bytes_with_nul(b"test\0").unwrap().as_ptr());
+    }
+}
+
+#[test]
+fn test_ops_stream_current_device() {
+    let s: *mut ffi::cubeb_stream = ptr::null_mut();
+    let mut device: *mut ffi::cubeb_device = ptr::null_mut();
+    assert_eq!(
+        unsafe { OPS.stream_get_current_device.unwrap()(s, &mut device) },
+        ffi::CUBEB_OK
+    );
+    assert_eq!(device, 0xDEAD_BEEF as *mut _);
+}
+
+#[test]
+fn test_ops_stream_set_input_mute() {
+    let s: *mut ffi::cubeb_stream = ptr::null_mut();
+    assert_eq!(
+        unsafe { OPS.stream_set_input_mute.unwrap()(s, 1) },
+        ffi::CUBEB_OK
+    );
+}
+
+#[test]
+fn test_ops_stream_set_input_processing_params() {
+    let s: *mut ffi::cubeb_stream = ptr::null_mut();
+    assert_eq!(
+        unsafe {
+            OPS.stream_set_input_processing_params.unwrap()(
+                s,
+                ffi::CUBEB_INPUT_PROCESSING_PARAM_ECHO_CANCELLATION,
+            )
+        },
+        ffi::CUBEB_OK
+    );
+}
+
+#[test]
+fn test_ops_stream_device_destroy() {
+    let s: *mut ffi::cubeb_stream = ptr::null_mut();
+    unsafe {
+        OPS.stream_device_destroy.unwrap()(s, 0xDEAD_BEEF as *mut _);
+    }
+}