Merge "rust: split Parcel enum into two types" (d02860bf) · Commits · e / devices / smdk4412 / android_frameworks_native

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))