Bug 1617369 - Reformat recent rust changes with rustfmt r=froydnj

# ignore-this-changeset

Depends on D77580

Differential Revision: https://phabricator.services.mozilla.com/D77581

media/audioipc/client/src/context.rs

@@ -14,13 +14,10 @@ use audioipc::codec::LengthDelimitedCodec;
 use audioipc::frame::{framed, Framed};
 use audioipc::platformhandle_passing::{framed_with_platformhandles, FramedWithPlatformHandles};
 use audioipc::{core, rpc};
-use audioipc::{
-    messages, messages::DeviceCollectionReq, messages::DeviceCollectionResp, ClientMessage,
-    ServerMessage,
-};
+use audioipc::{messages, messages::DeviceCollectionReq, messages::DeviceCollectionResp, ClientMessage, ServerMessage};
 use cubeb_backend::{
-    ffi, Context, ContextOps, DeviceCollectionRef, DeviceId, DeviceType, Error, Ops, Result,
-    Stream, StreamParams, StreamParamsRef,
+    ffi, Context, ContextOps, DeviceCollectionRef, DeviceId, DeviceType, Error, Ops, Result, Stream, StreamParams,
+    StreamParamsRef,
 };
 use futures::Future;
 use futures_cpupool::{CpuFuture, CpuPool};
@@ -38,10 +35,8 @@ struct CubebClient;
 impl rpc::Client for CubebClient {
     type Request = ServerMessage;
     type Response = ClientMessage;
-    type Transport = FramedWithPlatformHandles<
-        audioipc::AsyncMessageStream,
-        LengthDelimitedCodec<Self::Request, Self::Response>,
-    >;
+    type Transport =
+        FramedWithPlatformHandles<audioipc::AsyncMessageStream, LengthDelimitedCodec<Self::Request, Self::Response>>;
 }
 
 pub const CLIENT_OPS: Ops = capi_new!(ClientContext, ClientStream);
@@ -141,16 +136,12 @@ impl rpc::Server for DeviceCollectionServer {
     type Request = DeviceCollectionReq;
     type Response = DeviceCollectionResp;
     type Future = CpuFuture<Self::Response, ()>;
-    type Transport =
-        Framed<audioipc::AsyncMessageStream, LengthDelimitedCodec<Self::Response, Self::Request>>;
+    type Transport = Framed<audioipc::AsyncMessageStream, LengthDelimitedCodec<Self::Response, Self::Request>>;
 
     fn process(&mut self, req: Self::Request) -> Self::Future {
         match req {
             DeviceCollectionReq::DeviceChange(device_type) => {
-                trace!(
-                    "ctx_thread: DeviceChange Callback: device_type={}",
-                    device_type
-                );
+                trace!("ctx_thread: DeviceChange Callback: device_type={}", device_type);
 
                 let devtype = cubeb_backend::DeviceType::from_bits_truncate(device_type);
 
@@ -166,14 +157,10 @@ impl rpc::Server for DeviceCollectionServer {
                 self.cpu_pool.spawn_fn(move || {
                     run_in_callback(|| {
                         if devtype.contains(cubeb_backend::DeviceType::INPUT) {
-                            unsafe {
-                                input_cb.unwrap()(ptr::null_mut(), input_user_ptr as *mut c_void)
-                            }
+                            unsafe { input_cb.unwrap()(ptr::null_mut(), input_user_ptr as *mut c_void) }
                         }
                         if devtype.contains(cubeb_backend::DeviceType::OUTPUT) {
-                            unsafe {
-                                output_cb.unwrap()(ptr::null_mut(), output_user_ptr as *mut c_void)
-                            }
+                            unsafe { output_cb.unwrap()(ptr::null_mut(), output_user_ptr as *mut c_void) }
                         }
                     });
 
@@ -206,8 +193,7 @@ impl ContextOps for ClientContext {
         let thread_create_callback = params.thread_create_callback;
         let thread_destroy_callback = params.thread_destroy_callback;
 
-        let server_stream =
-            unsafe { audioipc::MessageStream::from_raw_fd(params.server_connection) };
+        let server_stream = unsafe { audioipc::MessageStream::from_raw_fd(params.server_connection) };
 
         let core = core::spawn_thread(
             "AudioIPC Client RPC",
@@ -231,8 +217,8 @@ impl ContextOps for ClientContext {
         // will return errors the caller expects to handle.
         let _ = send_recv!(rpc, ClientConnect(std::process::id()) => ClientConnected);
 
-        let backend_id = send_recv!(rpc, ContextGetBackendId => ContextBackendId())
-            .unwrap_or_else(|_| "(remote error)".to_string());
+        let backend_id =
+            send_recv!(rpc, ContextGetBackendId => ContextBackendId()).unwrap_or_else(|_| "(remote error)".to_string());
         let backend_id = CString::new(backend_id).expect("backend_id query failed");
 
         let cpu_pool = futures_cpupool::Builder::new()
@@ -277,11 +263,7 @@ impl ContextOps for ClientContext {
         send_recv!(self.rpc(), ContextGetPreferredSampleRate => ContextPreferredSampleRate())
     }
 
-    fn enumerate_devices(
-        &mut self,
-        devtype: DeviceType,
-        collection: &DeviceCollectionRef,
-    ) -> Result<()> {
+    fn enumerate_devices(&mut self, devtype: DeviceType, collection: &DeviceCollectionRef) -> Result<()> {
         assert_not_in_callback();
         let v: Vec<ffi::cubeb_device_info> = match send_recv!(self.rpc(),
                              ContextGetDeviceEnumeration(devtype.bits()) =>
@@ -304,11 +286,7 @@ impl ContextOps for ClientContext {
         assert_not_in_callback();
         unsafe {
             let coll = &mut *collection.as_ptr();
-            let mut devices = Vec::from_raw_parts(
-                coll.device as *mut ffi::cubeb_device_info,
-                coll.count,
-                coll.count,
-            );
+            let mut devices = Vec::from_raw_parts(coll.device as *mut ffi::cubeb_device_info, coll.count, coll.count);
             for dev in &mut devices {
                 if !dev.device_id.is_null() {
                     let _ = CString::from_raw(dev.device_id as *mut _);
@@ -383,8 +361,7 @@ impl ContextOps for ClientContext {
                                  ContextSetupDeviceCollectionCallback =>
                                  ContextSetupDeviceCollectionCallback())?;
 
-            let stream =
-                unsafe { audioipc::MessageStream::from_raw_fd(fds.platform_handles[0].into_raw()) };
+            let stream = unsafe { audioipc::MessageStream::from_raw_fd(fds.platform_handles[0].into_raw()) };
 
             // TODO: The lowest comms layer expects exactly 3 PlatformHandles, but we only
             // need one here.  Drop the dummy handles the other side sent us to discard.

media/audioipc/client/src/stream.rs

@@ -62,8 +62,7 @@ impl rpc::Server for CallbackServer {
     type Request = CallbackReq;
     type Response = CallbackResp;
     type Future = CpuFuture<Self::Response, ()>;
-    type Transport =
-        Framed<audioipc::AsyncMessageStream, LengthDelimitedCodec<Self::Response, Self::Request>>;
+    type Transport = Framed<audioipc::AsyncMessageStream, LengthDelimitedCodec<Self::Response, Self::Request>>;
 
     fn process(&mut self, req: Self::Request) -> Self::Future {
         match req {
@@ -94,10 +93,7 @@ impl rpc::Server for CallbackServer {
                 self.cpu_pool.spawn_fn(move || {
                     // TODO: This is proof-of-concept. Make it better.
                     let input_ptr: *const u8 = match input_shm {
-                        Some(shm) => shm
-                            .get_slice(nframes as usize * input_frame_size)
-                            .unwrap()
-                            .as_ptr(),
+                        Some(shm) => shm.get_slice(nframes as usize * input_frame_size).unwrap().as_ptr(),
                         None => ptr::null(),
                     };
                     let output_ptr: *mut u8 = match output_shm {
@@ -173,13 +169,9 @@ impl<'ctx> ClientStream<'ctx> {
         let rpc = ctx.rpc();
         let data = send_recv!(rpc, StreamInit(init_params) => StreamCreated())?;
 
-        debug!(
-            "token = {}, handles = {:?}",
-            data.token, data.platform_handles
-        );
+        debug!("token = {}, handles = {:?}", data.token, data.platform_handles);
 
-        let stream =
-            unsafe { audioipc::MessageStream::from_raw_fd(data.platform_handles[0].into_raw()) };
+        let stream = unsafe { audioipc::MessageStream::from_raw_fd(data.platform_handles[0].into_raw()) };
 
         let input_file = unsafe { data.platform_handles[1].into_file() };
         let input_shm = if has_input {

security/manager/ssl/osclientcerts/src/bindings_macos.rs

@@ -17,7 +17,11 @@ pub type SecKeyAlgorithm = CFStringRef;
 extern "C" {
     // Available starting macOS 10.3
     pub fn SecCertificateGetTypeID() -> CFTypeID;
-    pub fn SecTrustCreateWithCertificates(certificates: SecCertificateRef, policies: SecPolicyRef, trust: *mut SecTrustRef) -> OSStatus;
+    pub fn SecTrustCreateWithCertificates(
+        certificates: SecCertificateRef,
+        policies: SecPolicyRef,
+        trust: *mut SecTrustRef,
+    ) -> OSStatus;
     pub fn SecIdentityGetTypeID() -> CFTypeID;
     pub fn SecIdentityCopyCertificate(
         identityRef: SecIdentityRef,

xpcom/rust/gecko_logger/src/lib.rs

@@ -6,9 +6,9 @@
 
 extern crate env_logger;
 extern crate log;
-use log::{Level, LevelFilter};
 #[cfg(not(target_os = "android"))]
 use log::Log;
+use log::{Level, LevelFilter};
 use std::boxed::Box;
 use std::cmp;
 use std::collections::HashMap;