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

Commit 727ede4a authored by Tianyu Jiang's avatar Tianyu Jiang
Browse files

Fix non camelCase function names 

Android Framework C++ Code Style Guidelines says that function names
should be camelCase: http://go/droidcppstyle

Test: m, mma in frameworks/native
Bug: 68273829
Change-Id: I2f661c06b31b2e72cd0eee3d91b95531b60ec939
parent 3b8439cc

libs/ui/BufferHubBuffer.cpp

+31 −31
Original line number Diff line number Diff line
@@ -24,12 +24,12 @@ 
#include <utils/Trace.h>



using ::android::base::unique_fd;

using ::android::BufferHubDefs::AnyClientAcquired;

using ::android::BufferHubDefs::AnyClientGained;

using ::android::BufferHubDefs::IsClientAcquired;

using ::android::BufferHubDefs::IsClientGained;

using ::android::BufferHubDefs::IsClientPosted;

using ::android::BufferHubDefs::IsClientReleased;

using ::android::BufferHubDefs::isAnyClientAcquired;

using ::android::BufferHubDefs::isAnyClientGained;

using ::android::BufferHubDefs::isClientAcquired;

using ::android::BufferHubDefs::isClientGained;

using ::android::BufferHubDefs::isClientPosted;

using ::android::BufferHubDefs::isClientReleased;

using ::android::frameworks::bufferhub::V1_0::BufferHubStatus;

using ::android::frameworks::bufferhub::V1_0::BufferTraits;

using ::android::frameworks::bufferhub::V1_0::IBufferClient;
@@ -39,22 +39,22 @@ using ::android::hardware::graphics::common::V1_2::HardwareBufferDescription; 


namespace android {



std::unique_ptr<BufferHubBuffer> BufferHubBuffer::Create(uint32_t width, uint32_t height,

std::unique_ptr<BufferHubBuffer> BufferHubBuffer::create(uint32_t width, uint32_t height,

                                                         uint32_t layerCount, uint32_t format,

                                                         uint64_t usage, size_t userMetadataSize) {

    auto buffer = std::unique_ptr<BufferHubBuffer>(

            new BufferHubBuffer(width, height, layerCount, format, usage, userMetadataSize));

    return buffer->IsValid() ? std::move(buffer) : nullptr;

    return buffer->isValid() ? std::move(buffer) : nullptr;

}



std::unique_ptr<BufferHubBuffer> BufferHubBuffer::Import(const native_handle_t* token) {

std::unique_ptr<BufferHubBuffer> BufferHubBuffer::import(const native_handle_t* token) {

    if (token == nullptr) {

        ALOGE("%s: token cannot be nullptr!", __FUNCTION__);

        return nullptr;

    }



    auto buffer = std::unique_ptr<BufferHubBuffer>(new BufferHubBuffer(token));

    return buffer->IsValid() ? std::move(buffer) : nullptr;

    return buffer->isValid() ? std::move(buffer) : nullptr;

}



BufferHubBuffer::BufferHubBuffer(uint32_t width, uint32_t height, uint32_t layerCount,
@@ -169,8 +169,8 @@ int BufferHubBuffer::initWithBufferTraits(const BufferTraits& bufferTraits) { 


    // Import fds. Dup fds because hidl_handle owns the fds.

    unique_fd ashmemFd(fcntl(bufferTraits.bufferInfo->data[0], F_DUPFD_CLOEXEC, 0));

    mMetadata = BufferHubMetadata::Import(std::move(ashmemFd));

    if (!mMetadata.IsValid()) {

    mMetadata = BufferHubMetadata::import(std::move(ashmemFd));

    if (!mMetadata.isValid()) {

        ALOGE("%s: Received an invalid metadata.", __FUNCTION__);

        return -EINVAL;

    }
@@ -196,20 +196,20 @@ int BufferHubBuffer::initWithBufferTraits(const BufferTraits& bufferTraits) { 


    uint32_t userMetadataSize;

    memcpy(&userMetadataSize, &bufferTraits.bufferInfo->data[4], sizeof(userMetadataSize));

    if (mMetadata.user_metadata_size() != userMetadataSize) {

    if (mMetadata.userMetadataSize() != userMetadataSize) {

        ALOGE("%s: user metadata size not match: expected %u, actual %zu.", __FUNCTION__,

              userMetadataSize, mMetadata.user_metadata_size());

              userMetadataSize, mMetadata.userMetadataSize());

        return -EINVAL;

    }



    size_t metadataSize = static_cast<size_t>(mMetadata.metadata_size());

    size_t metadataSize = static_cast<size_t>(mMetadata.metadataSize());

    if (metadataSize < BufferHubDefs::kMetadataHeaderSize) {

        ALOGE("%s: metadata too small: %zu", __FUNCTION__, metadataSize);

        return -EINVAL;

    }



    // Populate shortcuts to the atomics in metadata.

    auto metadata_header = mMetadata.metadata_header();

    auto metadata_header = mMetadata.metadataHeader();

    mBufferState = &metadata_header->buffer_state;

    mFenceState = &metadata_header->fence_state;

    mActiveClientsBitMask = &metadata_header->active_clients_bit_mask;
@@ -235,16 +235,16 @@ int BufferHubBuffer::initWithBufferTraits(const BufferTraits& bufferTraits) { 
    return 0;

}



int BufferHubBuffer::Gain() {

int BufferHubBuffer::gain() {

    uint32_t currentBufferState = mBufferState->load(std::memory_order_acquire);

    if (IsClientGained(currentBufferState, mClientStateMask)) {

    if (isClientGained(currentBufferState, mClientStateMask)) {

        ALOGV("%s: Buffer is already gained by this client %" PRIx32 ".", __FUNCTION__,

              mClientStateMask);

        return 0;

    }

    do {

        if (AnyClientGained(currentBufferState & (~mClientStateMask)) ||

            AnyClientAcquired(currentBufferState)) {

        if (isAnyClientGained(currentBufferState & (~mClientStateMask)) ||

            isAnyClientAcquired(currentBufferState)) {

            ALOGE("%s: Buffer is in use, id=%d mClientStateMask=%" PRIx32 " state=%" PRIx32 ".",

                  __FUNCTION__, mId, mClientStateMask, currentBufferState);

            return -EBUSY;
@@ -258,11 +258,11 @@ int BufferHubBuffer::Gain() { 
    return 0;

}



int BufferHubBuffer::Post() {

int BufferHubBuffer::post() {

    uint32_t currentBufferState = mBufferState->load(std::memory_order_acquire);

    uint32_t updatedBufferState = (~mClientStateMask) & BufferHubDefs::kHighBitsMask;

    do {

        if (!IsClientGained(currentBufferState, mClientStateMask)) {

        if (!isClientGained(currentBufferState, mClientStateMask)) {

            ALOGE("%s: Cannot post a buffer that is not gained by this client. buffer_id=%d "

                  "mClientStateMask=%" PRIx32 " state=%" PRIx32 ".",

                  __FUNCTION__, mId, mClientStateMask, currentBufferState);
@@ -277,16 +277,16 @@ int BufferHubBuffer::Post() { 
    return 0;

}



int BufferHubBuffer::Acquire() {

int BufferHubBuffer::acquire() {

    uint32_t currentBufferState = mBufferState->load(std::memory_order_acquire);

    if (IsClientAcquired(currentBufferState, mClientStateMask)) {

    if (isClientAcquired(currentBufferState, mClientStateMask)) {

        ALOGV("%s: Buffer is already acquired by this client %" PRIx32 ".", __FUNCTION__,

              mClientStateMask);

        return 0;

    }

    uint32_t updatedBufferState = 0U;

    do {

        if (!IsClientPosted(currentBufferState, mClientStateMask)) {

        if (!isClientPosted(currentBufferState, mClientStateMask)) {

            ALOGE("%s: Cannot acquire a buffer that is not in posted state. buffer_id=%d "

                  "mClientStateMask=%" PRIx32 " state=%" PRIx32 ".",

                  __FUNCTION__, mId, mClientStateMask, currentBufferState);
@@ -301,9 +301,9 @@ int BufferHubBuffer::Acquire() { 
    return 0;

}



int BufferHubBuffer::Release() {

int BufferHubBuffer::release() {

    uint32_t currentBufferState = mBufferState->load(std::memory_order_acquire);

    if (IsClientReleased(currentBufferState, mClientStateMask)) {

    if (isClientReleased(currentBufferState, mClientStateMask)) {

        ALOGV("%s: Buffer is already released by this client %" PRIx32 ".", __FUNCTION__,

              mClientStateMask);

        return 0;
@@ -318,17 +318,17 @@ int BufferHubBuffer::Release() { 
    return 0;

}



bool BufferHubBuffer::IsReleased() const {

bool BufferHubBuffer::isReleased() const {

    return (mBufferState->load(std::memory_order_acquire) &

            mActiveClientsBitMask->load(std::memory_order_acquire)) == 0;

}



bool BufferHubBuffer::IsValid() const {

bool BufferHubBuffer::isValid() const {

    return mBufferHandle.getNativeHandle() != nullptr && mId >= 0 && mClientStateMask != 0U &&

            mEventFd.get() >= 0 && mMetadata.IsValid() && mBufferClient != nullptr;

            mEventFd.get() >= 0 && mMetadata.isValid() && mBufferClient != nullptr;

}



native_handle_t* BufferHubBuffer::Duplicate() {

native_handle_t* BufferHubBuffer::duplicate() {

    if (mBufferClient == nullptr) {

        ALOGE("%s: missing BufferClient!", __FUNCTION__);

        return nullptr;

libs/ui/BufferHubMetadata.cpp

+4 −4
Original line number Diff line number Diff line
@@ -34,7 +34,7 @@ using BufferHubDefs::kMetadataHeaderSize; 
using BufferHubDefs::MetadataHeader;



/* static */

BufferHubMetadata BufferHubMetadata::Create(size_t userMetadataSize) {

BufferHubMetadata BufferHubMetadata::create(size_t userMetadataSize) {

    // The size the of metadata buffer is used as the "width" parameter during allocation. Thus it

    // cannot overflow uint32_t.

    if (userMetadataSize >= (std::numeric_limits<uint32_t>::max() - kMetadataHeaderSize)) {
@@ -59,11 +59,11 @@ BufferHubMetadata BufferHubMetadata::Create(size_t userMetadataSize) { 
        return {};

    }



    return BufferHubMetadata::Import(std::move(ashmemFd));

    return BufferHubMetadata::import(std::move(ashmemFd));

}



/* static */

BufferHubMetadata BufferHubMetadata::Import(unique_fd ashmemFd) {

BufferHubMetadata BufferHubMetadata::import(unique_fd ashmemFd) {

    if (!ashmem_valid(ashmemFd.get())) {

        ALOGE("BufferHubMetadata::Import: invalid ashmem fd.");

        return {};
@@ -94,7 +94,7 @@ BufferHubMetadata::BufferHubMetadata(size_t userMetadataSize, unique_fd ashmemFd 


BufferHubMetadata::~BufferHubMetadata() {

    if (mMetadataHeader != nullptr) {

        int ret = munmap(mMetadataHeader, metadata_size());

        int ret = munmap(mMetadataHeader, metadataSize());

        ALOGE_IF(ret != 0,

                 "BufferHubMetadata::~BufferHubMetadata: failed to unmap ashmem, error=%d.", errno);

        mMetadataHeader = nullptr;

libs/ui/GraphicBuffer.cpp

+1 −1
Original line number Diff line number Diff line
@@ -100,7 +100,7 @@ GraphicBuffer::GraphicBuffer(std::unique_ptr<BufferHubBuffer> buffer) : GraphicB 
        return;

    }



    mInitCheck = initWithHandle(buffer->DuplicateHandle(), /*method=*/TAKE_UNREGISTERED_HANDLE,

    mInitCheck = initWithHandle(buffer->duplicateHandle(), /*method=*/TAKE_UNREGISTERED_HANDLE,

                                buffer->desc().width, buffer->desc().height,

                                static_cast<PixelFormat>(buffer->desc().format),

                                buffer->desc().layers, buffer->desc().usage, buffer->desc().stride);

libs/ui/include/ui/BufferHubBuffer.h

+14 −14
Original line number Diff line number Diff line
@@ -29,14 +29,14 @@ namespace android { 
class BufferHubBuffer {

public:

    // Allocates a standalone BufferHubBuffer.

    static std::unique_ptr<BufferHubBuffer> Create(uint32_t width, uint32_t height,

    static std::unique_ptr<BufferHubBuffer> create(uint32_t width, uint32_t height,

                                                   uint32_t layerCount, uint32_t format,

                                                   uint64_t usage, size_t userMetadataSize);



    // Imports the given token to a BufferHubBuffer. Not taking ownership of the token. Caller

    // should close and destroy the token after calling this function regardless of output.

    // TODO(b/122543147): use a movable wrapper for token

    static std::unique_ptr<BufferHubBuffer> Import(const native_handle_t* token);

    static std::unique_ptr<BufferHubBuffer> import(const native_handle_t* token);



    BufferHubBuffer(const BufferHubBuffer&) = delete;

    void operator=(const BufferHubBuffer&) = delete;
@@ -52,51 +52,51 @@ public: 


    // Duplicate the underlying Gralloc buffer handle. Caller is responsible to free the handle

    // after use.

    native_handle_t* DuplicateHandle() {

    native_handle_t* duplicateHandle() {

        return native_handle_clone(mBufferHandle.getNativeHandle());

    }



    const BufferHubEventFd& eventFd() const { return mEventFd; }



    // Returns the current value of MetadataHeader::buffer_state.

    uint32_t buffer_state() const { return mBufferState->load(std::memory_order_acquire); }

    uint32_t bufferState() const { return mBufferState->load(std::memory_order_acquire); }



    // A state mask which is unique to a buffer hub client among all its siblings sharing the same

    // concrete graphic buffer.

    uint32_t client_state_mask() const { return mClientStateMask; }

    uint32_t clientStateMask() const { return mClientStateMask; }



    size_t user_metadata_size() const { return mMetadata.user_metadata_size(); }

    size_t userMetadataSize() const { return mMetadata.userMetadataSize(); }



    // Returns true if the BufferClient is still alive.

    bool IsConnected() const { return mBufferClient->ping().isOk(); }

    bool isConnected() const { return mBufferClient->ping().isOk(); }



    // Returns true if the buffer is valid: non-null buffer handle, valid id, valid client bit mask,

    // valid metadata and valid buffer client

    bool IsValid() const;

    bool isValid() const;



    // Gains the buffer for exclusive write permission. Read permission is implied once a buffer is

    // gained.

    // The buffer can be gained as long as there is no other client in acquired or gained state.

    int Gain();

    int gain();



    // Posts the gained buffer for other buffer clients to use the buffer.

    // The buffer can be posted iff the buffer state for this client is gained.

    // After posting the buffer, this client is put to released state and does not have access to

    // the buffer for this cycle of the usage of the buffer.

    int Post();

    int post();



    // Acquires the buffer for shared read permission.

    // The buffer can be acquired iff the buffer state for this client is posted.

    int Acquire();

    int acquire();



    // Releases the buffer.

    // The buffer can be released from any buffer state.

    // After releasing the buffer, this client no longer have any permissions to the buffer for the

    // current cycle of the usage of the buffer.

    int Release();

    int release();



    // Returns whether the buffer is released by all active clients or not.

    bool IsReleased() const;

    bool isReleased() const;



    // Creates a token that stands for this BufferHubBuffer client and could be used for Import to

    // create another BufferHubBuffer. The new BufferHubBuffer will share the same underlying
@@ -104,7 +104,7 @@ public: 
    // should free it after use.

    // Returns a valid token on success, nullptr on failure.

    // TODO(b/122543147): use a movable wrapper for token

    native_handle_t* Duplicate();

    native_handle_t* duplicate();



private:

    BufferHubBuffer(uint32_t width, uint32_t height, uint32_t layerCount, uint32_t format,

libs/ui/include/ui/BufferHubDefs.h

+8 −8
Original line number Diff line number Diff line
@@ -63,19 +63,19 @@ static constexpr uint32_t kHighBitsMask = ~kLowbitsMask; 
static constexpr uint32_t kFirstClientBitMask = (1U << kMaxNumberOfClients) + 1U;



// Returns true if any of the client is in gained state.

static inline bool AnyClientGained(uint32_t state) {

static inline bool isAnyClientGained(uint32_t state) {

    uint32_t high_bits = state >> kMaxNumberOfClients;

    uint32_t low_bits = state & kLowbitsMask;

    return high_bits == low_bits && low_bits != 0U;

}



// Returns true if the input client is in gained state.

static inline bool IsClientGained(uint32_t state, uint32_t client_bit_mask) {

static inline bool isClientGained(uint32_t state, uint32_t client_bit_mask) {

    return state == client_bit_mask;

}



// Returns true if any of the client is in posted state.

static inline bool AnyClientPosted(uint32_t state) {

static inline bool isAnyClientPosted(uint32_t state) {

    uint32_t high_bits = state >> kMaxNumberOfClients;

    uint32_t low_bits = state & kLowbitsMask;

    uint32_t posted_or_acquired = high_bits ^ low_bits;
@@ -83,7 +83,7 @@ static inline bool AnyClientPosted(uint32_t state) { 
}



// Returns true if the input client is in posted state.

static inline bool IsClientPosted(uint32_t state, uint32_t client_bit_mask) {

static inline bool isClientPosted(uint32_t state, uint32_t client_bit_mask) {

    uint32_t client_bits = state & client_bit_mask;

    if (client_bits == 0U) return false;

    uint32_t low_bits = client_bits & kLowbitsMask;
@@ -91,7 +91,7 @@ static inline bool IsClientPosted(uint32_t state, uint32_t client_bit_mask) { 
}



// Return true if any of the client is in acquired state.

static inline bool AnyClientAcquired(uint32_t state) {

static inline bool isAnyClientAcquired(uint32_t state) {

    uint32_t high_bits = state >> kMaxNumberOfClients;

    uint32_t low_bits = state & kLowbitsMask;

    uint32_t posted_or_acquired = high_bits ^ low_bits;
@@ -99,7 +99,7 @@ static inline bool AnyClientAcquired(uint32_t state) { 
}



// Return true if the input client is in acquired state.

static inline bool IsClientAcquired(uint32_t state, uint32_t client_bit_mask) {

static inline bool isClientAcquired(uint32_t state, uint32_t client_bit_mask) {

    uint32_t client_bits = state & client_bit_mask;

    if (client_bits == 0U) return false;

    uint32_t high_bits = client_bits & kHighBitsMask;
@@ -107,13 +107,13 @@ static inline bool IsClientAcquired(uint32_t state, uint32_t client_bit_mask) { 
}



// Returns true if the input client is in released state.

static inline bool IsClientReleased(uint32_t state, uint32_t client_bit_mask) {

static inline bool isClientReleased(uint32_t state, uint32_t client_bit_mask) {

    return (state & client_bit_mask) == 0U;

}



// Returns the next available buffer client's client_state_masks.

// @params union_bits. Union of all existing clients' client_state_masks.

static inline uint32_t FindNextAvailableClientStateMask(uint32_t union_bits) {

static inline uint32_t findNextAvailableClientStateMask(uint32_t union_bits) {

    uint32_t low_union = union_bits & kLowbitsMask;

    if (low_union == kLowbitsMask) return 0U;

    uint32_t incremented = low_union + 1U;