Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8618c485 authored by Alice Ryhl's avatar Alice Ryhl
Browse files

rust: split Parcel enum into two types 

Test: m
Bug: 200676345
Change-Id: I351ea0500035dafe0c8444cbb96074725c1c8630
parent e50adf3c

libs/binder/rust/src/binder.rs

+27 −27
Original line number Diff line number Diff line
@@ -17,7 +17,7 @@ 
//! Trait definitions for binder objects



use crate::error::{status_t, Result, StatusCode};

use crate::parcel::{OwnedParcel, Parcel};

use crate::parcel::{Parcel, BorrowedParcel};

use crate::proxy::{DeathRecipient, SpIBinder, WpIBinder};

use crate::sys;
@@ -129,7 +129,7 @@ pub trait Remotable: Send + Sync { 
    /// Handle and reply to a request to invoke a transaction on this object.

    ///

    /// `reply` may be [`None`] if the sender does not expect a reply.

    fn on_transact(&self, code: TransactionCode, data: &Parcel, reply: &mut Parcel) -> Result<()>;

    fn on_transact(&self, code: TransactionCode, data: &BorrowedParcel<'_>, reply: &mut BorrowedParcel<'_>) -> Result<()>;



    /// Handle a request to invoke the dump transaction on this

    /// object.
@@ -177,25 +177,25 @@ pub trait IBinderInternal: IBinder { 
    fn get_extension(&mut self) -> Result<Option<SpIBinder>>;



    /// Create a Parcel that can be used with `submit_transact`.

    fn prepare_transact(&self) -> Result<OwnedParcel>;

    fn prepare_transact(&self) -> Result<Parcel>;



    /// Perform a generic operation with the object.

    ///

    /// The provided [`OwnedParcel`] must have been created by a call to

    /// The provided [`Parcel`] must have been created by a call to

    /// `prepare_transact` on the same binder.

    ///

    /// # Arguments

    ///

    /// * `code` - Transaction code for the operation.

    /// * `data` - [`OwnedParcel`] with input data.

    /// * `data` - [`Parcel`] with input data.

    /// * `flags` - Transaction flags, e.g. marking the transaction as

    ///   asynchronous ([`FLAG_ONEWAY`](FLAG_ONEWAY)).

    fn submit_transact(

        &self,

        code: TransactionCode,

        data: OwnedParcel,

        data: Parcel,

        flags: TransactionFlags,

    ) -> Result<OwnedParcel>;

    ) -> Result<Parcel>;



    /// Perform a generic operation with the object. This is a convenience

    /// method that internally calls `prepare_transact` followed by
@@ -206,15 +206,15 @@ pub trait IBinderInternal: IBinder { 
    /// * `flags` - Transaction flags, e.g. marking the transaction as

    ///   asynchronous ([`FLAG_ONEWAY`](FLAG_ONEWAY))

    /// * `input_callback` A callback for building the `Parcel`.

    fn transact<F: FnOnce(&mut Parcel) -> Result<()>>(

    fn transact<F: FnOnce(BorrowedParcel<'_>) -> Result<()>>(

        &self,

        code: TransactionCode,

        flags: TransactionFlags,

        input_callback: F,

    ) -> Result<Parcel> {

        let mut parcel = self.prepare_transact()?;

        input_callback(&mut parcel.borrowed())?;

        self.submit_transact(code, parcel, flags).map(OwnedParcel::into_parcel)

        input_callback(parcel.borrowed())?;

        self.submit_transact(code, parcel, flags)

    }

}
@@ -475,8 +475,8 @@ impl<I: FromIBinder + ?Sized> Eq for Weak<I> {} 
///     fn on_transact(

///         &self,

///         code: TransactionCode,

///         data: &Parcel,

///         reply: &mut Parcel,

///         data: &BorrowedParcel,

///         reply: &mut BorrowedParcel,

///     ) -> Result<()> {

///         // ...

///     }
@@ -655,13 +655,13 @@ pub struct BinderFeatures { 
/// have the following type:

///

/// ```

/// # use binder::{Interface, TransactionCode, Parcel};

/// # use binder::{Interface, TransactionCode, BorrowedParcel};

/// # trait Placeholder {

/// fn on_transact(

///     service: &dyn Interface,

///     code: TransactionCode,

///     data: &Parcel,

///     reply: &mut Parcel,

///     data: &BorrowedParcel,

///     reply: &mut BorrowedParcel,

/// ) -> binder::Result<()>;

/// # }

/// ```
@@ -676,7 +676,7 @@ pub struct BinderFeatures { 
/// using the provided function, `on_transact`.

///

/// ```

/// use binder::{declare_binder_interface, Binder, Interface, TransactionCode, Parcel};

/// use binder::{declare_binder_interface, Binder, Interface, TransactionCode, BorrowedParcel};

///

/// pub trait IServiceManager: Interface {

///     // remote methods...
@@ -692,8 +692,8 @@ pub struct BinderFeatures { 
/// fn on_transact(

///     service: &dyn IServiceManager,

///     code: TransactionCode,

///     data: &Parcel,

///     reply: &mut Parcel,

///     data: &BorrowedParcel,

///     reply: &mut BorrowedParcel,

/// ) -> binder::Result<()> {

///     // ...

///     Ok(())
@@ -847,7 +847,7 @@ macro_rules! declare_binder_interface { 
                $descriptor

            }



            fn on_transact(&self, code: $crate::TransactionCode, data: &$crate::Parcel, reply: &mut $crate::Parcel) -> $crate::Result<()> {

            fn on_transact(&self, code: $crate::TransactionCode, data: &$crate::BorrowedParcel<'_>, reply: &mut $crate::BorrowedParcel<'_>) -> $crate::Result<()> {

                match $on_transact(&*self.0, code, data, reply) {

                    // The C++ backend converts UNEXPECTED_NULL into an exception

                    Err($crate::StatusCode::UNEXPECTED_NULL) => {
@@ -922,14 +922,14 @@ macro_rules! declare_binder_interface { 
        where

            dyn $interface: $crate::Interface

        {

            fn serialize(&self, parcel: &mut $crate::parcel::Parcel) -> $crate::Result<()> {

            fn serialize(&self, parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {

                let binder = $crate::Interface::as_binder(self);

                parcel.write(&binder)

            }

        }



        impl $crate::parcel::SerializeOption for dyn $interface + '_ {

            fn serialize_option(this: Option<&Self>, parcel: &mut $crate::parcel::Parcel) -> $crate::Result<()> {

            fn serialize_option(this: Option<&Self>, parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {

                parcel.write(&this.map($crate::Interface::as_binder))

            }

        }
@@ -988,14 +988,14 @@ macro_rules! declare_binder_interface { 
        }



        impl<P: $crate::BinderAsyncPool> $crate::parcel::Serialize for dyn $async_interface<P> + '_ {

            fn serialize(&self, parcel: &mut $crate::parcel::Parcel) -> $crate::Result<()> {

            fn serialize(&self, parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {

                let binder = $crate::Interface::as_binder(self);

                parcel.write(&binder)

            }

        }



        impl<P: $crate::BinderAsyncPool> $crate::parcel::SerializeOption for dyn $async_interface<P> + '_ {

            fn serialize_option(this: Option<&Self>, parcel: &mut $crate::parcel::Parcel) -> $crate::Result<()> {

            fn serialize_option(this: Option<&Self>, parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {

                parcel.write(&this.map($crate::Interface::as_binder))

            }

        }
@@ -1040,26 +1040,26 @@ macro_rules! declare_binder_enum { 
        }



        impl $crate::parcel::Serialize for $enum {

            fn serialize(&self, parcel: &mut $crate::parcel::Parcel) -> $crate::Result<()> {

            fn serialize(&self, parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {

                parcel.write(&self.0)

            }

        }



        impl $crate::parcel::SerializeArray for $enum {

            fn serialize_array(slice: &[Self], parcel: &mut $crate::parcel::Parcel) -> $crate::Result<()> {

            fn serialize_array(slice: &[Self], parcel: &mut $crate::parcel::BorrowedParcel<'_>) -> $crate::Result<()> {

                let v: Vec<$backing> = slice.iter().map(|x| x.0).collect();

                <$backing as binder::parcel::SerializeArray>::serialize_array(&v[..], parcel)

            }

        }



        impl $crate::parcel::Deserialize for $enum {

            fn deserialize(parcel: &$crate::parcel::Parcel) -> $crate::Result<Self> {

            fn deserialize(parcel: &$crate::parcel::BorrowedParcel<'_>) -> $crate::Result<Self> {

                parcel.read().map(Self)

            }

        }



        impl $crate::parcel::DeserializeArray for $enum {

            fn deserialize_array(parcel: &$crate::parcel::Parcel) -> $crate::Result<Option<Vec<Self>>> {

            fn deserialize_array(parcel: &$crate::parcel::BorrowedParcel<'_>) -> $crate::Result<Option<Vec<Self>>> {

                let v: Option<Vec<$backing>> =

                    <$backing as binder::parcel::DeserializeArray>::deserialize_array(parcel)?;

                Ok(v.map(|v| v.into_iter().map(Self).collect()))

libs/binder/rust/src/lib.rs

+3 −3
Original line number Diff line number Diff line
@@ -50,8 +50,8 @@ 
//! fn on_transact(

//!     service: &dyn ITest,

//!     code: TransactionCode,

//!     _data: &Parcel,

//!     reply: &mut Parcel,

//!     _data: &BorrowedParcel,

//!     reply: &mut BorrowedParcel,

//! ) -> binder::Result<()> {

//!     match code {

//!         SpIBinder::FIRST_CALL_TRANSACTION => {
@@ -115,7 +115,7 @@ pub use crate::binder::{ 
pub use crate::binder_async::{BoxFuture, BinderAsyncPool};

pub use error::{status_t, ExceptionCode, Result, Status, StatusCode};

pub use native::{add_service, force_lazy_services_persist, register_lazy_service, Binder};

pub use parcel::{OwnedParcel, Parcel};

pub use parcel::{BorrowedParcel, Parcel};

pub use proxy::{get_interface, get_service, wait_for_interface, wait_for_service};

pub use proxy::{AssociateClass, DeathRecipient, Proxy, SpIBinder, WpIBinder};

pub use state::{ProcessState, ThreadState};

libs/binder/rust/src/native.rs

+8 −8
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ use crate::binder::{ 
    AsNative, Interface, InterfaceClassMethods, Remotable, Stability, TransactionCode,

};

use crate::error::{status_result, status_t, Result, StatusCode};

use crate::parcel::{Parcel, Serialize};

use crate::parcel::{BorrowedParcel, Serialize};

use crate::proxy::SpIBinder;

use crate::sys;
@@ -161,8 +161,8 @@ impl<T: Remotable> Binder<T> { 
    ///        # fn on_transact(

    ///        #     service: &dyn IBar,

    ///        #     code: TransactionCode,

    ///        #     data: &Parcel,

    ///        #     reply: &mut Parcel,

    ///        #     data: &BorrowedParcel,

    ///        #     reply: &mut BorrowedParcel,

    ///        # ) -> binder::Result<()> {

    ///        #     Ok(())

    ///        # }
@@ -277,8 +277,8 @@ impl<T: Remotable> InterfaceClassMethods for Binder<T> { 
        reply: *mut sys::AParcel,

    ) -> status_t {

        let res = {

            let mut reply = Parcel::borrowed(reply).unwrap();

            let data = Parcel::borrowed(data as *mut sys::AParcel).unwrap();

            let mut reply = BorrowedParcel::from_raw(reply).unwrap();

            let data = BorrowedParcel::from_raw(data as *mut sys::AParcel).unwrap();

            let object = sys::AIBinder_getUserData(binder);

            let binder: &T = &*(object as *const T);

            binder.on_transact(code, &data, &mut reply)
@@ -384,7 +384,7 @@ impl<T: Remotable> Deref for Binder<T> { 
}



impl<B: Remotable> Serialize for Binder<B> {

    fn serialize(&self, parcel: &mut Parcel) -> Result<()> {

    fn serialize(&self, parcel: &mut BorrowedParcel<'_>) -> Result<()> {

        parcel.write_binder(Some(&self.as_binder()))

    }

}
@@ -503,8 +503,8 @@ impl Remotable for () { 
    fn on_transact(

        &self,

        _code: TransactionCode,

        _data: &Parcel,

        _reply: &mut Parcel,

        _data: &BorrowedParcel<'_>,

        _reply: &mut BorrowedParcel<'_>,

    ) -> Result<()> {

        Ok(())

    }

libs/binder/rust/src/parcel.rs

+297 −160

File changed.

Preview size limit exceeded, changes collapsed.

libs/binder/rust/src/parcel/file_descriptor.rs

+5 −5
Original line number Diff line number Diff line
@@ -15,7 +15,7 @@ 
 */



use super::{

    Deserialize, DeserializeArray, DeserializeOption, Parcel, Serialize, SerializeArray,

    Deserialize, DeserializeArray, DeserializeOption, BorrowedParcel, Serialize, SerializeArray,

    SerializeOption,

};

use crate::binder::AsNative;
@@ -61,7 +61,7 @@ impl IntoRawFd for ParcelFileDescriptor { 
}



impl Serialize for ParcelFileDescriptor {

    fn serialize(&self, parcel: &mut Parcel) -> Result<()> {

    fn serialize(&self, parcel: &mut BorrowedParcel<'_>) -> Result<()> {

        let fd = self.0.as_raw_fd();

        let status = unsafe {

            // Safety: `Parcel` always contains a valid pointer to an
@@ -78,7 +78,7 @@ impl Serialize for ParcelFileDescriptor { 
impl SerializeArray for ParcelFileDescriptor {}



impl SerializeOption for ParcelFileDescriptor {

    fn serialize_option(this: Option<&Self>, parcel: &mut Parcel) -> Result<()> {

    fn serialize_option(this: Option<&Self>, parcel: &mut BorrowedParcel<'_>) -> Result<()> {

        if let Some(f) = this {

            f.serialize(parcel)

        } else {
@@ -95,7 +95,7 @@ impl SerializeOption for ParcelFileDescriptor { 
}



impl DeserializeOption for ParcelFileDescriptor {

    fn deserialize_option(parcel: &Parcel) -> Result<Option<Self>> {

    fn deserialize_option(parcel: &BorrowedParcel<'_>) -> Result<Option<Self>> {

        let mut fd = -1i32;

        unsafe {

            // Safety: `Parcel` always contains a valid pointer to an
@@ -125,7 +125,7 @@ impl DeserializeOption for ParcelFileDescriptor { 
}



impl Deserialize for ParcelFileDescriptor {

    fn deserialize(parcel: &Parcel) -> Result<Self> {

    fn deserialize(parcel: &BorrowedParcel<'_>) -> Result<Self> {

        Deserialize::deserialize(parcel)

            .transpose()

            .unwrap_or(Err(StatusCode::UNEXPECTED_NULL))