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

Commit 37941652 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Parcel: deprecate unique_ptr read/write methods" am: 4d3171a4 

Original change: https://android-review.googlesource.com/c/platform/frameworks/native/+/1501936

Change-Id: Id62fa1b35c07f462a01ffde71935e141c6a1099e
parents 2bc66dfb 4d3171a4

libs/binder/include/binder/Parcel.h

+45 −45
Original line number Diff line number Diff line
@@ -131,7 +131,7 @@ public: 
    status_t            writeString8(const char* str, size_t len);

    status_t            writeString16(const String16& str);

    status_t            writeString16(const std::optional<String16>& str);

    status_t            writeString16(const std::unique_ptr<String16>& str);

    status_t            writeString16(const std::unique_ptr<String16>& str) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeString16(const char16_t* str, size_t len);

    status_t            writeStrongBinder(const sp<IBinder>& val);

    status_t            writeInt32Array(size_t len, const int32_t *val);
@@ -143,48 +143,48 @@ public: 
    // Take a UTF8 encoded string, convert to UTF16, write it to the parcel.

    status_t            writeUtf8AsUtf16(const std::string& str);

    status_t            writeUtf8AsUtf16(const std::optional<std::string>& str);

    status_t            writeUtf8AsUtf16(const std::unique_ptr<std::string>& str);

    status_t            writeUtf8AsUtf16(const std::unique_ptr<std::string>& str) __attribute__((deprecated("use std::optional version instead")));



    status_t            writeByteVector(const std::optional<std::vector<int8_t>>& val);

    status_t            writeByteVector(const std::unique_ptr<std::vector<int8_t>>& val);

    status_t            writeByteVector(const std::unique_ptr<std::vector<int8_t>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeByteVector(const std::vector<int8_t>& val);

    status_t            writeByteVector(const std::optional<std::vector<uint8_t>>& val);

    status_t            writeByteVector(const std::unique_ptr<std::vector<uint8_t>>& val);

    status_t            writeByteVector(const std::unique_ptr<std::vector<uint8_t>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeByteVector(const std::vector<uint8_t>& val);

    status_t            writeInt32Vector(const std::optional<std::vector<int32_t>>& val);

    status_t            writeInt32Vector(const std::unique_ptr<std::vector<int32_t>>& val);

    status_t            writeInt32Vector(const std::unique_ptr<std::vector<int32_t>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeInt32Vector(const std::vector<int32_t>& val);

    status_t            writeInt64Vector(const std::optional<std::vector<int64_t>>& val);

    status_t            writeInt64Vector(const std::unique_ptr<std::vector<int64_t>>& val);

    status_t            writeInt64Vector(const std::unique_ptr<std::vector<int64_t>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeInt64Vector(const std::vector<int64_t>& val);

    status_t            writeUint64Vector(const std::optional<std::vector<uint64_t>>& val);

    status_t            writeUint64Vector(const std::unique_ptr<std::vector<uint64_t>>& val);

    status_t            writeUint64Vector(const std::unique_ptr<std::vector<uint64_t>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeUint64Vector(const std::vector<uint64_t>& val);

    status_t            writeFloatVector(const std::optional<std::vector<float>>& val);

    status_t            writeFloatVector(const std::unique_ptr<std::vector<float>>& val);

    status_t            writeFloatVector(const std::unique_ptr<std::vector<float>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeFloatVector(const std::vector<float>& val);

    status_t            writeDoubleVector(const std::optional<std::vector<double>>& val);

    status_t            writeDoubleVector(const std::unique_ptr<std::vector<double>>& val);

    status_t            writeDoubleVector(const std::unique_ptr<std::vector<double>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeDoubleVector(const std::vector<double>& val);

    status_t            writeBoolVector(const std::optional<std::vector<bool>>& val);

    status_t            writeBoolVector(const std::unique_ptr<std::vector<bool>>& val);

    status_t            writeBoolVector(const std::unique_ptr<std::vector<bool>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeBoolVector(const std::vector<bool>& val);

    status_t            writeCharVector(const std::optional<std::vector<char16_t>>& val);

    status_t            writeCharVector(const std::unique_ptr<std::vector<char16_t>>& val);

    status_t            writeCharVector(const std::unique_ptr<std::vector<char16_t>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeCharVector(const std::vector<char16_t>& val);

    status_t            writeString16Vector(

                            const std::optional<std::vector<std::optional<String16>>>& val);

    status_t            writeString16Vector(

                            const std::unique_ptr<std::vector<std::unique_ptr<String16>>>& val);

                            const std::unique_ptr<std::vector<std::unique_ptr<String16>>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeString16Vector(const std::vector<String16>& val);

    status_t            writeUtf8VectorAsUtf16Vector(

                            const std::optional<std::vector<std::optional<std::string>>>& val);

    status_t            writeUtf8VectorAsUtf16Vector(

                            const std::unique_ptr<std::vector<std::unique_ptr<std::string>>>& val);

                            const std::unique_ptr<std::vector<std::unique_ptr<std::string>>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeUtf8VectorAsUtf16Vector(const std::vector<std::string>& val);



    status_t            writeStrongBinderVector(const std::optional<std::vector<sp<IBinder>>>& val);

    status_t            writeStrongBinderVector(const std::unique_ptr<std::vector<sp<IBinder>>>& val);

    status_t            writeStrongBinderVector(const std::unique_ptr<std::vector<sp<IBinder>>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeStrongBinderVector(const std::vector<sp<IBinder>>& val);



    // Write an Enum vector with underlying type int8_t.
@@ -194,21 +194,21 @@ public: 
    template<typename T, std::enable_if_t<std::is_enum_v<T> && std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            writeEnumVector(const std::optional<std::vector<T>>& val);

    template<typename T, std::enable_if_t<std::is_enum_v<T> && std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            writeEnumVector(const std::unique_ptr<std::vector<T>>& val);

    status_t            writeEnumVector(const std::unique_ptr<std::vector<T>>& val) __attribute__((deprecated("use std::optional version instead")));

    // Write an Enum vector with underlying type != int8_t.

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            writeEnumVector(const std::vector<T>& val);

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            writeEnumVector(const std::optional<std::vector<T>>& val);

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            writeEnumVector(const std::unique_ptr<std::vector<T>>& val);

    status_t            writeEnumVector(const std::unique_ptr<std::vector<T>>& val) __attribute__((deprecated("use std::optional version instead")));



    template<typename T>

    status_t            writeParcelableVector(const std::optional<std::vector<std::optional<T>>>& val);

    template<typename T>

    status_t            writeParcelableVector(const std::unique_ptr<std::vector<std::unique_ptr<T>>>& val);

    status_t            writeParcelableVector(const std::unique_ptr<std::vector<std::unique_ptr<T>>>& val) __attribute__((deprecated("use std::optional version instead")));

    template<typename T>

    status_t            writeParcelableVector(const std::shared_ptr<std::vector<std::unique_ptr<T>>>& val);

    status_t            writeParcelableVector(const std::shared_ptr<std::vector<std::unique_ptr<T>>>& val) __attribute__((deprecated("use std::optional version instead")));

    template<typename T>

    status_t            writeParcelableVector(const std::shared_ptr<std::vector<std::optional<T>>>& val);

    template<typename T>
@@ -217,7 +217,7 @@ public: 
    template<typename T>

    status_t            writeNullableParcelable(const std::optional<T>& parcelable);

    template<typename T>

    status_t            writeNullableParcelable(const std::unique_ptr<T>& parcelable);

    status_t            writeNullableParcelable(const std::unique_ptr<T>& parcelable) __attribute__((deprecated("use std::optional version instead")));



    status_t            writeParcelable(const Parcelable& parcelable);
@@ -232,7 +232,7 @@ public: 
    template<typename T>

    status_t            writeVectorSize(const std::optional<std::vector<T>>& val);

    template<typename T>

    status_t            writeVectorSize(const std::unique_ptr<std::vector<T>>& val);

    status_t            writeVectorSize(const std::unique_ptr<std::vector<T>>& val) __attribute__((deprecated("use std::optional version instead")));



    // Place a native_handle into the parcel (the native_handle's file-

    // descriptors are dup'ed, so it is safe to delete the native_handle
@@ -269,7 +269,7 @@ public: 
    status_t            writeUniqueFileDescriptorVector(

                            const std::optional<std::vector<base::unique_fd>>& val);

    status_t            writeUniqueFileDescriptorVector(

                            const std::unique_ptr<std::vector<base::unique_fd>>& val);

                            const std::unique_ptr<std::vector<base::unique_fd>>& val) __attribute__((deprecated("use std::optional version instead")));

    status_t            writeUniqueFileDescriptorVector(

                            const std::vector<base::unique_fd>& val);
@@ -317,7 +317,7 @@ public: 
    // Read a UTF16 encoded string, convert to UTF8

    status_t            readUtf8FromUtf16(std::string* str) const;

    status_t            readUtf8FromUtf16(std::optional<std::string>* str) const;

    status_t            readUtf8FromUtf16(std::unique_ptr<std::string>* str) const;

    status_t            readUtf8FromUtf16(std::unique_ptr<std::string>* str) const __attribute__((deprecated("use std::optional version instead")));



    const char*         readCString() const;

    String8             readString8() const;
@@ -326,7 +326,7 @@ public: 
    String16            readString16() const;

    status_t            readString16(String16* pArg) const;

    status_t            readString16(std::optional<String16>* pArg) const;

    status_t            readString16(std::unique_ptr<String16>* pArg) const;

    status_t            readString16(std::unique_ptr<String16>* pArg) const __attribute__((deprecated("use std::optional version instead")));

    const char16_t*     readString16Inplace(size_t* outLen) const;

    sp<IBinder>         readStrongBinder() const;

    status_t            readStrongBinder(sp<IBinder>* val) const;
@@ -337,14 +337,14 @@ public: 
    template<typename T, std::enable_if_t<std::is_enum_v<T> && std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            readEnumVector(std::vector<T>* val) const;

    template<typename T, std::enable_if_t<std::is_enum_v<T> && std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            readEnumVector(std::unique_ptr<std::vector<T>>* val) const;

    status_t            readEnumVector(std::unique_ptr<std::vector<T>>* val) const __attribute__((deprecated("use std::optional version instead")));

    template<typename T, std::enable_if_t<std::is_enum_v<T> && std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            readEnumVector(std::optional<std::vector<T>>* val) const;

    // Read an Enum vector with underlying type != int8_t.

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            readEnumVector(std::vector<T>* val) const;

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            readEnumVector(std::unique_ptr<std::vector<T>>* val) const;

    status_t            readEnumVector(std::unique_ptr<std::vector<T>>* val) const __attribute__((deprecated("use std::optional version instead")));

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            readEnumVector(std::optional<std::vector<T>>* val) const;
@@ -353,7 +353,7 @@ public: 
                            std::optional<std::vector<std::optional<T>>>* val) const;

    template<typename T>

    status_t            readParcelableVector(

                            std::unique_ptr<std::vector<std::unique_ptr<T>>>* val) const;

                            std::unique_ptr<std::vector<std::unique_ptr<T>>>* val) const __attribute__((deprecated("use std::optional version instead")));

    template<typename T>

    status_t            readParcelableVector(std::vector<T>* val) const;
@@ -362,7 +362,7 @@ public: 
    template<typename T>

    status_t            readParcelable(std::optional<T>* parcelable) const;

    template<typename T>

    status_t            readParcelable(std::unique_ptr<T>* parcelable) const;

    status_t            readParcelable(std::unique_ptr<T>* parcelable) const __attribute__((deprecated("use std::optional version instead")));



    template<typename T>

    status_t            readStrongBinder(sp<T>* val) const;
@@ -371,45 +371,45 @@ public: 
    status_t            readNullableStrongBinder(sp<T>* val) const;



    status_t            readStrongBinderVector(std::optional<std::vector<sp<IBinder>>>* val) const;

    status_t            readStrongBinderVector(std::unique_ptr<std::vector<sp<IBinder>>>* val) const;

    status_t            readStrongBinderVector(std::unique_ptr<std::vector<sp<IBinder>>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readStrongBinderVector(std::vector<sp<IBinder>>* val) const;



    status_t            readByteVector(std::optional<std::vector<int8_t>>* val) const;

    status_t            readByteVector(std::unique_ptr<std::vector<int8_t>>* val) const;

    status_t            readByteVector(std::unique_ptr<std::vector<int8_t>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readByteVector(std::vector<int8_t>* val) const;

    status_t            readByteVector(std::optional<std::vector<uint8_t>>* val) const;

    status_t            readByteVector(std::unique_ptr<std::vector<uint8_t>>* val) const;

    status_t            readByteVector(std::unique_ptr<std::vector<uint8_t>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readByteVector(std::vector<uint8_t>* val) const;

    status_t            readInt32Vector(std::optional<std::vector<int32_t>>* val) const;

    status_t            readInt32Vector(std::unique_ptr<std::vector<int32_t>>* val) const;

    status_t            readInt32Vector(std::unique_ptr<std::vector<int32_t>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readInt32Vector(std::vector<int32_t>* val) const;

    status_t            readInt64Vector(std::optional<std::vector<int64_t>>* val) const;

    status_t            readInt64Vector(std::unique_ptr<std::vector<int64_t>>* val) const;

    status_t            readInt64Vector(std::unique_ptr<std::vector<int64_t>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readInt64Vector(std::vector<int64_t>* val) const;

    status_t            readUint64Vector(std::optional<std::vector<uint64_t>>* val) const;

    status_t            readUint64Vector(std::unique_ptr<std::vector<uint64_t>>* val) const;

    status_t            readUint64Vector(std::unique_ptr<std::vector<uint64_t>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readUint64Vector(std::vector<uint64_t>* val) const;

    status_t            readFloatVector(std::optional<std::vector<float>>* val) const;

    status_t            readFloatVector(std::unique_ptr<std::vector<float>>* val) const;

    status_t            readFloatVector(std::unique_ptr<std::vector<float>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readFloatVector(std::vector<float>* val) const;

    status_t            readDoubleVector(std::optional<std::vector<double>>* val) const;

    status_t            readDoubleVector(std::unique_ptr<std::vector<double>>* val) const;

    status_t            readDoubleVector(std::unique_ptr<std::vector<double>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readDoubleVector(std::vector<double>* val) const;

    status_t            readBoolVector(std::optional<std::vector<bool>>* val) const;

    status_t            readBoolVector(std::unique_ptr<std::vector<bool>>* val) const;

    status_t            readBoolVector(std::unique_ptr<std::vector<bool>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readBoolVector(std::vector<bool>* val) const;

    status_t            readCharVector(std::optional<std::vector<char16_t>>* val) const;

    status_t            readCharVector(std::unique_ptr<std::vector<char16_t>>* val) const;

    status_t            readCharVector(std::unique_ptr<std::vector<char16_t>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readCharVector(std::vector<char16_t>* val) const;

    status_t            readString16Vector(

                            std::optional<std::vector<std::optional<String16>>>* val) const;

    status_t            readString16Vector(

                            std::unique_ptr<std::vector<std::unique_ptr<String16>>>* val) const;

                            std::unique_ptr<std::vector<std::unique_ptr<String16>>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readString16Vector(std::vector<String16>* val) const;

    status_t            readUtf8VectorFromUtf16Vector(

                            std::optional<std::vector<std::optional<std::string>>>* val) const;

    status_t            readUtf8VectorFromUtf16Vector(

                            std::unique_ptr<std::vector<std::unique_ptr<std::string>>>* val) const;

                            std::unique_ptr<std::vector<std::unique_ptr<std::string>>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readUtf8VectorFromUtf16Vector(std::vector<std::string>* val) const;



    template<typename T>
@@ -423,7 +423,7 @@ public: 
    template<typename T>

    status_t            resizeOutVector(std::optional<std::vector<T>>* val) const;

    template<typename T>

    status_t            resizeOutVector(std::unique_ptr<std::vector<T>>* val) const;

    status_t            resizeOutVector(std::unique_ptr<std::vector<T>>* val) const __attribute__((deprecated("use std::optional version instead")));

    template<typename T>

    status_t            reserveOutVector(std::vector<T>* val, size_t* size) const;

    template<typename T>
@@ -431,7 +431,7 @@ public: 
                                         size_t* size) const;

    template<typename T>

    status_t            reserveOutVector(std::unique_ptr<std::vector<T>>* val,

                                         size_t* size) const;

                                         size_t* size) const __attribute__((deprecated("use std::optional version instead")));



    // Like Parcel.java's readExceptionCode().  Reads the first int32

    // off of a Parcel's header, returning 0 or the negative error
@@ -467,7 +467,7 @@ public: 
    status_t            readUniqueFileDescriptorVector(

                            std::optional<std::vector<base::unique_fd>>* val) const;

    status_t            readUniqueFileDescriptorVector(

                            std::unique_ptr<std::vector<base::unique_fd>>* val) const;

                            std::unique_ptr<std::vector<base::unique_fd>>* val) const __attribute__((deprecated("use std::optional version instead")));

    status_t            readUniqueFileDescriptorVector(

                            std::vector<base::unique_fd>* val) const;
@@ -561,7 +561,7 @@ private: 
                                                status_t(Parcel::*read_func)(T*) const) const;

    template<typename T>

    status_t            readNullableTypedVector(std::unique_ptr<std::vector<T>>* val,

                                                status_t(Parcel::*read_func)(T*) const) const;

                                                status_t(Parcel::*read_func)(T*) const) const __attribute__((deprecated("use std::optional version instead")));

    template<typename T>

    status_t            readTypedVector(std::vector<T>* val,

                                        status_t(Parcel::*read_func)(T*) const) const;
@@ -573,13 +573,13 @@ private: 
                                                 status_t(Parcel::*write_func)(const T&));

    template<typename T>

    status_t            writeNullableTypedVector(const std::unique_ptr<std::vector<T>>& val,

                                                 status_t(Parcel::*write_func)(const T&));

                                                 status_t(Parcel::*write_func)(const T&)) __attribute__((deprecated("use std::optional version instead")));

    template<typename T>

    status_t            writeNullableTypedVector(const std::optional<std::vector<T>>& val,

                                                 status_t(Parcel::*write_func)(T));

    template<typename T>

    status_t            writeNullableTypedVector(const std::unique_ptr<std::vector<T>>& val,

                                                 status_t(Parcel::*write_func)(T));

                                                 status_t(Parcel::*write_func)(T)) __attribute__((deprecated("use std::optional version instead")));

    template<typename T>

    status_t            writeTypedVector(const std::vector<T>& val,

                                         status_t(Parcel::*write_func)(const T&));

libs/binder/parcel_fuzzer/binder.cpp

+3 −0
Original line number Diff line number Diff line
@@ -86,6 +86,8 @@ struct ExampleLightFlattenable : public android::LightFlattenablePod<ExampleLigh 
    PARCEL_READ_WITH_STATUS(T, FUN), \

    PARCEL_READ_NO_STATUS(T, FUN)



#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

// clang-format off

std::vector<ParcelRead<::android::Parcel>> BINDER_PARCEL_READ_FUNCTIONS {

    PARCEL_READ_NO_STATUS(size_t, dataSize),
@@ -289,3 +291,4 @@ std::vector<ParcelRead<::android::Parcel>> BINDER_PARCEL_READ_FUNCTIONS { 
    PARCEL_READ_WITH_STATUS(android::os::PersistableBundle, readParcelable),

};

// clang-format on

#pragma clang diagnostic pop