libgui: Make ISurfaceComposerClient a SafeInterface (a615e47e) · Commits · e / os / android_frameworks_native

include/gui/ISurfaceComposerClient.h

+36 −42

Original line number	Original line	Diff line number	Diff line
	@@ -14,30 +14,30 @@
	* limitations under the License.		* limitations under the License.
	*/		*/

	#ifndef ANDROID_GUI_ISURFACE_COMPOSER_CLIENT_H		#pragma once
	#define ANDROID_GUI_ISURFACE_COMPOSER_CLIENT_H

	#include <stdint.h>
	#include <sys/types.h>

	#include <utils/Errors.h>
	#include <utils/RefBase.h>

	#include <binder/IInterface.h>		#include <binder/IInterface.h>
			#include <binder/SafeInterface.h>
	#include <ui/FrameStats.h>
	#include <ui/PixelFormat.h>		#include <ui/PixelFormat.h>

	namespace android {		namespace android {
	// ----------------------------------------------------------------------------

			class FrameStats;
	class IGraphicBufferProducer;		class IGraphicBufferProducer;

	class ISurfaceComposerClient : public IInterface		class ISurfaceComposerClient : public IInterface {
	{
	public:		public:
	DECLARE_META_INTERFACE(SurfaceComposerClient)		DECLARE_META_INTERFACE(SurfaceComposerClient)

			enum class Tag : uint32_t {
			CreateSurface = IBinder::FIRST_CALL_TRANSACTION,
			DestroySurface,
			ClearLayerFrameStats,
			GetLayerFrameStats,
			GetTransformToDisplayInverse,
			Last,
			};

	// flags for createSurface()		// flags for createSurface()
	enum { // (keep in sync with Surface.java)		enum { // (keep in sync with Surface.java)
	eHidden = 0x00000004,		eHidden = 0x00000004,
	@@ -57,11 +57,9 @@ public:
	/*		/*
	* Requires ACCESS_SURFACE_FLINGER permission		* Requires ACCESS_SURFACE_FLINGER permission
	*/		*/
	virtual status_t createSurface(		virtual status_t createSurface(const String8& name, uint32_t w, uint32_t h, PixelFormat format,
	const String8& name, uint32_t w, uint32_t h,		uint32_t flags, const sp<IBinder>& parent, uint32_t windowType,
	PixelFormat format, uint32_t flags,		uint32_t ownerUid, sp<IBinder>* handle,
	const sp<IBinder>& parent, uint32_t windowType, uint32_t ownerUid,
	sp<IBinder>* handle,
	sp<IGraphicBufferProducer>* gbp) = 0;		sp<IGraphicBufferProducer>* gbp) = 0;

	/*		/*
	@@ -83,16 +81,12 @@ public:
	bool* outTransformToDisplayInverse) const = 0;		bool* outTransformToDisplayInverse) const = 0;
	};		};

	// ----------------------------------------------------------------------------		class BnSurfaceComposerClient : public SafeBnInterface<ISurfaceComposerClient> {

	class BnSurfaceComposerClient: public BnInterface<ISurfaceComposerClient> {
	public:		public:
	virtual status_t onTransact(uint32_t code, const Parcel& data,		BnSurfaceComposerClient()
	Parcel* reply, uint32_t flags = 0);		: SafeBnInterface<ISurfaceComposerClient>("BnSurfaceComposerClient") {}
	};

	// ----------------------------------------------------------------------------		status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
			};
	}; // namespace android

	#endif // ANDROID_GUI_ISURFACE_COMPOSER_CLIENT_H		} // namespace android

libs/gui/ISurfaceComposerClient.cpp

+54 −149

Original line number	Original line	Diff line number	Diff line
	@@ -17,116 +17,64 @@
	// tag as surfaceflinger		// tag as surfaceflinger
	#define LOG_TAG "SurfaceFlinger"		#define LOG_TAG "SurfaceFlinger"

	#include <stdio.h>
	#include <stdint.h>		#include <stdint.h>
			#include <stdio.h>
	#include <sys/types.h>		#include <sys/types.h>

	#include <binder/Parcel.h>
	#include <binder/IPCThreadState.h>		#include <binder/IPCThreadState.h>
	#include <binder/IServiceManager.h>		#include <binder/IServiceManager.h>
			#include <binder/Parcel.h>
			#include <binder/SafeInterface.h>

			#include <ui/FrameStats.h>
	#include <ui/Point.h>		#include <ui/Point.h>
	#include <ui/Rect.h>		#include <ui/Rect.h>

	#include <gui/IGraphicBufferProducer.h>		#include <gui/IGraphicBufferProducer.h>
	#include <gui/ISurfaceComposerClient.h>		#include <gui/ISurfaceComposerClient.h>
	#include <private/gui/LayerState.h>

	// ---------------------------------------------------------------------------

	namespace android {		namespace android {

	enum {		class BpSurfaceComposerClient : public SafeBpInterface<ISurfaceComposerClient> {
	CREATE_SURFACE = IBinder::FIRST_CALL_TRANSACTION,
	DESTROY_SURFACE,
	CLEAR_LAYER_FRAME_STATS,
	GET_LAYER_FRAME_STATS,
	GET_TRANSFORM_TO_DISPLAY_INVERSE
	};

	class BpSurfaceComposerClient : public BpInterface<ISurfaceComposerClient>
	{
	public:		public:
	explicit BpSurfaceComposerClient(const sp<IBinder>& impl)		explicit BpSurfaceComposerClient(const sp<IBinder>& impl)
	: BpInterface<ISurfaceComposerClient>(impl) {		: SafeBpInterface<ISurfaceComposerClient>(impl, "BpSurfaceComposerClient") {}
	}

	virtual ~BpSurfaceComposerClient();		~BpSurfaceComposerClient() override;

	virtual status_t createSurface(const String8& name, uint32_t width,
	uint32_t height, PixelFormat format, uint32_t flags,
	const sp<IBinder>& parent, uint32_t windowType, uint32_t ownerUid,
	sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp) {
	Parcel data, reply;
	data.writeInterfaceToken(ISurfaceComposerClient::getInterfaceDescriptor());
	data.writeString8(name);
	data.writeUint32(width);
	data.writeUint32(height);
	data.writeInt32(static_cast<int32_t>(format));
	data.writeUint32(flags);
	data.writeUint32(windowType);
	data.writeUint32(ownerUid);
	if (parent != nullptr) {
	data.writeStrongBinder(parent);
	}
	remote()->transact(CREATE_SURFACE, data, &reply);
	*handle = reply.readStrongBinder();
	*gbp = interface_cast<IGraphicBufferProducer>(reply.readStrongBinder());
	return reply.readInt32();
	}

	virtual status_t destroySurface(const sp<IBinder>& handle) {		status_t createSurface(const String8& name, uint32_t width, uint32_t height, PixelFormat format,
	Parcel data, reply;		uint32_t flags, const sp<IBinder>& parent, uint32_t windowType,
	data.writeInterfaceToken(ISurfaceComposerClient::getInterfaceDescriptor());		uint32_t ownerUid, sp<IBinder>* handle,
	data.writeStrongBinder(handle);		sp<IGraphicBufferProducer>* gbp) override {
	remote()->transact(DESTROY_SURFACE, data, &reply);		return callRemote<decltype(&ISurfaceComposerClient::createSurface)>(Tag::CreateSurface,
	return reply.readInt32();		name, width, height,
			format, flags, parent,
			windowType, ownerUid,
			handle, gbp);
	}		}

	virtual status_t clearLayerFrameStats(const sp<IBinder>& handle) const {		status_t destroySurface(const sp<IBinder>& handle) override {
	Parcel data, reply;		return callRemote<decltype(&ISurfaceComposerClient::destroySurface)>(Tag::DestroySurface,
	data.writeInterfaceToken(ISurfaceComposerClient::getInterfaceDescriptor());		handle);
	data.writeStrongBinder(handle);
	remote()->transact(CLEAR_LAYER_FRAME_STATS, data, &reply);
	return reply.readInt32();
	}		}

	virtual status_t getLayerFrameStats(const sp<IBinder>& handle, FrameStats* outStats) const {		status_t clearLayerFrameStats(const sp<IBinder>& handle) const override {
	Parcel data, reply;		return callRemote<decltype(
	data.writeInterfaceToken(ISurfaceComposerClient::getInterfaceDescriptor());		&ISurfaceComposerClient::clearLayerFrameStats)>(Tag::ClearLayerFrameStats, handle);
	data.writeStrongBinder(handle);
	remote()->transact(GET_LAYER_FRAME_STATS, data, &reply);
	reply.read(*outStats);
	return reply.readInt32();
	}		}

	virtual status_t getTransformToDisplayInverse(const sp<IBinder>& handle,		status_t getLayerFrameStats(const sp<IBinder>& handle, FrameStats* outStats) const override {
	bool* outTransformToDisplayInverse) const {		return callRemote<decltype(
	Parcel data, reply;		&ISurfaceComposerClient::getLayerFrameStats)>(Tag::GetLayerFrameStats, handle,
	status_t result =		outStats);
	data.writeInterfaceToken(ISurfaceComposerClient::getInterfaceDescriptor());
	if (result != NO_ERROR) {
	return result;
	}		}
	result = data.writeStrongBinder(handle);
	if (result != NO_ERROR) {		status_t getTransformToDisplayInverse(const sp<IBinder>& handle,
	return result;		bool* outTransformToDisplayInverse) const override {
	}		return callRemote<decltype(
	result = remote()->transact(GET_TRANSFORM_TO_DISPLAY_INVERSE, data, &reply);		&ISurfaceComposerClient::
	if (result != NO_ERROR) {		getTransformToDisplayInverse)>(Tag::GetTransformToDisplayInverse, handle,
	return result;		outTransformToDisplayInverse);
	}
	int transformInverse;
	result = reply.readInt32(&transformInverse);
	if (result != NO_ERROR) {
	return result;
	}
	*outTransformToDisplayInverse = transformInverse != 0 ? true : false;
	status_t result2 = reply.readInt32(&result);
	if (result2 != NO_ERROR) {
	return result2;
	}
	return result;
	}		}
	};		};

	@@ -138,75 +86,32 @@ IMPLEMENT_META_INTERFACE(SurfaceComposerClient, "android.ui.ISurfaceComposerClie

	// ----------------------------------------------------------------------		// ----------------------------------------------------------------------

	status_t BnSurfaceComposerClient::onTransact(		status_t BnSurfaceComposerClient::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
	uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)		uint32_t flags) {
	{		if (code < IBinder::FIRST_CALL_TRANSACTION \|\| code >= static_cast<uint32_t>(Tag::Last)) {
	switch(code) {		return BBinder::onTransact(code, data, reply, flags);
	case CREATE_SURFACE: {
	CHECK_INTERFACE(ISurfaceComposerClient, data, reply);
	String8 name = data.readString8();
	uint32_t width = data.readUint32();
	uint32_t height = data.readUint32();
	PixelFormat format = static_cast<PixelFormat>(data.readInt32());
	uint32_t createFlags = data.readUint32();
	uint32_t windowType = data.readUint32();
	uint32_t ownerUid = data.readUint32();
	sp<IBinder> parent = nullptr;
	if (data.dataAvail() > 0) {
	parent = data.readStrongBinder();
	}
	sp<IBinder> handle;
	sp<IGraphicBufferProducer> gbp;
	status_t result = createSurface(name, width, height, format,
	createFlags, parent, windowType, ownerUid, &handle, &gbp);
	reply->writeStrongBinder(handle);
	reply->writeStrongBinder(IInterface::asBinder(gbp));
	reply->writeInt32(result);
	return NO_ERROR;
	}
	case DESTROY_SURFACE: {
	CHECK_INTERFACE(ISurfaceComposerClient, data, reply);
	reply->writeInt32(destroySurface( data.readStrongBinder() ) );
	return NO_ERROR;
	}
	case CLEAR_LAYER_FRAME_STATS: {
	CHECK_INTERFACE(ISurfaceComposerClient, data, reply);
	sp<IBinder> handle = data.readStrongBinder();
	status_t result = clearLayerFrameStats(handle);
	reply->writeInt32(result);
	return NO_ERROR;
	}		}
	case GET_LAYER_FRAME_STATS: {		auto tag = static_cast<Tag>(code);
	CHECK_INTERFACE(ISurfaceComposerClient, data, reply);		switch (tag) {
	sp<IBinder> handle = data.readStrongBinder();		case Tag::CreateSurface: {
	FrameStats stats;		return callLocal(data, reply, &ISurfaceComposerClient::createSurface);
	status_t result = getLayerFrameStats(handle, &stats);
	reply->write(stats);
	reply->writeInt32(result);
	return NO_ERROR;
	}		}
	case GET_TRANSFORM_TO_DISPLAY_INVERSE: {		case Tag::DestroySurface: {
	CHECK_INTERFACE(ISurfaceComposerClient, data, reply);		return callLocal(data, reply, &ISurfaceComposerClient::destroySurface);
	sp<IBinder> handle;
	status_t result = data.readStrongBinder(&handle);
	if (result != NO_ERROR) {
	return result;
	}		}
	bool transformInverse = false;		case Tag::ClearLayerFrameStats: {
	result = getTransformToDisplayInverse(handle, &transformInverse);		return callLocal(data, reply, &ISurfaceComposerClient::clearLayerFrameStats);
	if (result != NO_ERROR) {
	return result;
	}		}
	result = reply->writeInt32(transformInverse ? 1 : 0);		case Tag::GetLayerFrameStats: {
	if (result != NO_ERROR) {		return callLocal(data, reply, &ISurfaceComposerClient::getLayerFrameStats);
	return result;
	}		}
	result = reply->writeInt32(NO_ERROR);		case Tag::GetTransformToDisplayInverse: {
	return result;		return callLocal(data, reply, &ISurfaceComposerClient::getTransformToDisplayInverse);
	}		}
	default:		case Tag::Last:
			// Should not be possible because of the check at the beginning of the method
	return BBinder::onTransact(code, data, reply, flags);		return BBinder::onTransact(code, data, reply, flags);
	}		}
	}		}

	}; // namespace android		} // namespace android