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

Commit 662a899e authored by Dan Stoza's avatar Dan Stoza
Browse files

libbinder: Add int64_t/uint64_t to SafeInterface 

Adds support for sending and receiving int64_t and uint64_t parameters
as part of a SafeInterface.

Test: New tests in binderSafeInterfaceTest
Change-Id: I3d27dd006591084b5c48f1bcb4d6dca40b679d23
parent 0c9a1ed9

libs/binder/include/binder/SafeInterface.h

+18 −0
Original line number Diff line number Diff line
@@ -121,6 +121,24 @@ public: 
        }

    };

    template <typename I>

    struct HandleInt<true, 8, I> {

        static status_t read(const ParcelHandler& handler, const Parcel& parcel, I* i) {

            return handler.callParcel("readInt64", [&]() { return parcel.readInt64(i); });

        }

        static status_t write(const ParcelHandler& handler, Parcel* parcel, I i) {

            return handler.callParcel("writeInt64", [&]() { return parcel->writeInt64(i); });

        }

    };

    template <typename I>

    struct HandleInt<false, 8, I> {

        static status_t read(const ParcelHandler& handler, const Parcel& parcel, I* i) {

            return handler.callParcel("readUint64", [&]() { return parcel.readUint64(i); });

        }

        static status_t write(const ParcelHandler& handler, Parcel* parcel, I i) {

            return handler.callParcel("writeUint64", [&]() { return parcel->writeUint64(i); });

        }

    };

    template <typename I>

    typename std::enable_if<std::is_integral<I>::value, status_t>::type read(const Parcel& parcel,

                                                                             I* i) const {

        return HandleInt<std::is_signed<I>::value, sizeof(I), I>::read(*this, parcel, i);

libs/binder/tests/binderSafeInterfaceTest.cpp

+48 −0
Original line number Diff line number Diff line
@@ -168,6 +168,8 @@ public: 
        CallMeBack,

        IncrementInt32,

        IncrementUint32,

        IncrementInt64,

        IncrementUint64,

        IncrementTwo,

        Last,

    };
@@ -190,6 +192,8 @@ public: 
    virtual void callMeBack(const sp<ICallback>& callback, int32_t a) const = 0;

    virtual status_t increment(int32_t a, int32_t* aPlusOne) const = 0;

    virtual status_t increment(uint32_t a, uint32_t* aPlusOne) const = 0;

    virtual status_t increment(int64_t a, int64_t* aPlusOne) const = 0;

    virtual status_t increment(uint64_t a, uint64_t* aPlusOne) const = 0;



    // This tests that input/output parameter interleaving works correctly

    virtual status_t increment(int32_t a, int32_t* aPlusOne, int32_t b,
@@ -251,6 +255,16 @@ public: 
        using Signature = status_t (ISafeInterfaceTest::*)(uint32_t, uint32_t*) const;

        return callRemote<Signature>(Tag::IncrementUint32, a, aPlusOne);

    }

    status_t increment(int64_t a, int64_t* aPlusOne) const override {

        ALOG(LOG_INFO, getLogTag(), "%s", __PRETTY_FUNCTION__);

        using Signature = status_t (ISafeInterfaceTest::*)(int64_t, int64_t*) const;

        return callRemote<Signature>(Tag::IncrementInt64, a, aPlusOne);

    }

    status_t increment(uint64_t a, uint64_t* aPlusOne) const override {

        ALOG(LOG_INFO, getLogTag(), "%s", __PRETTY_FUNCTION__);

        using Signature = status_t (ISafeInterfaceTest::*)(uint64_t, uint64_t*) const;

        return callRemote<Signature>(Tag::IncrementUint64, a, aPlusOne);

    }

    status_t increment(int32_t a, int32_t* aPlusOne, int32_t b, int32_t* bPlusOne) const override {

        ALOG(LOG_INFO, getLogTag(), "%s", __PRETTY_FUNCTION__);

        using Signature =
@@ -326,6 +340,16 @@ public: 
        *aPlusOne = a + 1;

        return NO_ERROR;

    }

    status_t increment(int64_t a, int64_t* aPlusOne) const override {

        ALOG(LOG_INFO, getLogTag(), "%s", __PRETTY_FUNCTION__);

        *aPlusOne = a + 1;

        return NO_ERROR;

    }

    status_t increment(uint64_t a, uint64_t* aPlusOne) const override {

        ALOG(LOG_INFO, getLogTag(), "%s", __PRETTY_FUNCTION__);

        *aPlusOne = a + 1;

        return NO_ERROR;

    }

    status_t increment(int32_t a, int32_t* aPlusOne, int32_t b, int32_t* bPlusOne) const override {

        ALOG(LOG_INFO, getLogTag(), "%s", __PRETTY_FUNCTION__);

        *aPlusOne = a + 1;
@@ -379,6 +403,14 @@ public: 
                using Signature = status_t (ISafeInterfaceTest::*)(uint32_t, uint32_t*) const;

                return callLocal<Signature>(data, reply, &ISafeInterfaceTest::increment);

            }

            case ISafeInterfaceTest::Tag::IncrementInt64: {

                using Signature = status_t (ISafeInterfaceTest::*)(int64_t, int64_t*) const;

                return callLocal<Signature>(data, reply, &ISafeInterfaceTest::increment);

            }

            case ISafeInterfaceTest::Tag::IncrementUint64: {

                using Signature = status_t (ISafeInterfaceTest::*)(uint64_t, uint64_t*) const;

                return callLocal<Signature>(data, reply, &ISafeInterfaceTest::increment);

            }

            case ISafeInterfaceTest::Tag::IncrementTwo: {

                using Signature = status_t (ISafeInterfaceTest::*)(int32_t, int32_t*, int32_t,

                                                                   int32_t*) const;
@@ -544,6 +576,22 @@ TEST_F(SafeInterfaceTest, TestIncrementUint32) { 
    ASSERT_EQ(a + 1, aPlusOne);

}



TEST_F(SafeInterfaceTest, TestIncrementInt64) {

    const int64_t a = 1;

    int64_t aPlusOne = 0;

    status_t result = mSafeInterfaceTest->increment(a, &aPlusOne);

    ASSERT_EQ(NO_ERROR, result);

    ASSERT_EQ(a + 1, aPlusOne);

}



TEST_F(SafeInterfaceTest, TestIncrementUint64) {

    const uint64_t a = 1;

    uint64_t aPlusOne = 0;

    status_t result = mSafeInterfaceTest->increment(a, &aPlusOne);

    ASSERT_EQ(NO_ERROR, result);

    ASSERT_EQ(a + 1, aPlusOne);

}



TEST_F(SafeInterfaceTest, TestIncrementTwo) {

    const int32_t a = 1;

    int32_t aPlusOne = 0;