Merge "Fix style violation according to go/droidcppstyle" (45a16abf) · Commits · e / os / android_frameworks_native-old

libs/ui/BufferHubBuffer.cpp

+4 −4

Original line number	Diff line number	Diff line
		@@ -209,10 +209,10 @@ int BufferHubBuffer::initWithBufferTraits(const BufferTraits& bufferTraits) {
		}

		// Populate shortcuts to the atomics in metadata.
		auto metadata_header = mMetadata.metadataHeader();
		mBufferState = &metadata_header->buffer_state;
		mFenceState = &metadata_header->fence_state;
		mActiveClientsBitMask = &metadata_header->active_clients_bit_mask;
		auto metadataHeader = mMetadata.metadataHeader();
		mBufferState = &metadataHeader->buffer_state;
		mFenceState = &metadataHeader->fence_state;
		mActiveClientsBitMask = &metadataHeader->active_clients_bit_mask;
		// The C++ standard recommends (but does not require) that lock-free atomic operations are
		// also address-free, that is, suitable for communication between processes using shared
		// memory.

services/bufferhub/BufferNode.cpp

+13 −13

Original line number	Diff line number	Diff line
		@@ -28,17 +28,17 @@ void BufferNode::initializeMetadata() {
		}

		// Allocates a new BufferNode.
		BufferNode::BufferNode(uint32_t width, uint32_t height, uint32_t layer_count, uint32_t format,
		uint64_t usage, size_t user_metadata_size, int id)
		BufferNode::BufferNode(uint32_t width, uint32_t height, uint32_t layerCount, uint32_t format,
		uint64_t usage, size_t userMetadataSize, int id)
		: mId(id) {
		uint32_t out_stride = 0;
		uint32_t outStride = 0;
		// graphicBufferId is not used in GraphicBufferAllocator::allocate
		// TODO(b/112338294) After move to the service folder, stop using the
		// hardcoded service name "bufferhub".
		int ret = GraphicBufferAllocator::get().allocate(width, height, format, layer_count, usage,
		int ret = GraphicBufferAllocator::get().allocate(width, height, format, layerCount, usage,
		const_cast<const native_handle_t**>(
		&mBufferHandle),
		&out_stride,
		&outStride,
		/graphicBufferId=/0,
		/requestor=/"bufferhub");

		@@ -49,12 +49,12 @@ BufferNode::BufferNode(uint32_t width, uint32_t height, uint32_t layer_count, ui

		mBufferDesc.width = width;
		mBufferDesc.height = height;
		mBufferDesc.layers = layer_count;
		mBufferDesc.layers = layerCount;
		mBufferDesc.format = format;
		mBufferDesc.usage = usage;
		mBufferDesc.stride = out_stride;
		mBufferDesc.stride = outStride;

		mMetadata = BufferHubMetadata::create(user_metadata_size);
		mMetadata = BufferHubMetadata::create(userMetadataSize);
		if (!mMetadata.isValid()) {
		ALOGE("%s: Failed to allocate metadata.", __FUNCTION__);
		return;
		@@ -83,23 +83,23 @@ uint32_t BufferNode::getActiveClientsBitMask() const {

		uint32_t BufferNode::addNewActiveClientsBitToMask() {
		uint32_t currentActiveClientsBitMask = getActiveClientsBitMask();
		uint32_t client_state_mask = 0U;
		uint32_t clientStateMask = 0U;
		uint32_t updatedActiveClientsBitMask = 0U;
		do {
		client_state_mask =
		clientStateMask =
		BufferHubDefs::findNextAvailableClientStateMask(currentActiveClientsBitMask);
		if (client_state_mask == 0U) {
		if (clientStateMask == 0U) {
		ALOGE("%s: reached the maximum number of channels per buffer node: %d.", __FUNCTION__,
		BufferHubDefs::kMaxNumberOfClients);
		errno = E2BIG;
		return 0U;
		}
		updatedActiveClientsBitMask = currentActiveClientsBitMask \| client_state_mask;
		updatedActiveClientsBitMask = currentActiveClientsBitMask \| clientStateMask;
		} while (!(mActiveClientsBitMask->compare_exchange_weak(currentActiveClientsBitMask,
		updatedActiveClientsBitMask,
		std::memory_order_acq_rel,
		std::memory_order_acquire)));
		return client_state_mask;
		return clientStateMask;
		}

		void BufferNode::removeClientsBitFromMask(const uint32_t& value) {

services/bufferhub/include/bufferhub/BufferNode.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -16,8 +16,8 @@ namespace implementation {
		class BufferNode {
		public:
		// Allocates a new BufferNode.
		BufferNode(uint32_t width, uint32_t height, uint32_t layer_count, uint32_t format,
		uint64_t usage, size_t user_metadata_size, int id = -1);
		BufferNode(uint32_t width, uint32_t height, uint32_t layerCount, uint32_t format,
		uint64_t usage, size_t userMetadataSize, int id = -1);

		~BufferNode();

services/bufferhub/tests/BufferNode_test.cpp

+33 −34

Original line number	Diff line number	Diff line
		@@ -26,79 +26,78 @@ const size_t kUserMetadataSize = 0;
		class BufferNodeTest : public ::testing::Test {
		protected:
		void SetUp() override {
		buffer_node =
		mBufferNode =
		new BufferNode(kWidth, kHeight, kLayerCount, kFormat, kUsage, kUserMetadataSize);
		ASSERT_TRUE(buffer_node->isValid());
		ASSERT_TRUE(mBufferNode->isValid());
		}

		void TearDown() override {
		if (buffer_node != nullptr) {
		delete buffer_node;
		if (mBufferNode != nullptr) {
		delete mBufferNode;
		}
		}

		BufferNode* buffer_node = nullptr;
		BufferNode* mBufferNode = nullptr;
		};

		TEST_F(BufferNodeTest, TestCreateBufferNode) {
		EXPECT_EQ(buffer_node->userMetadataSize(), kUserMetadataSize);
		EXPECT_EQ(mBufferNode->userMetadataSize(), kUserMetadataSize);
		// Test the handle just allocated is good (i.e. able to be imported)
		GraphicBufferMapper& mapper = GraphicBufferMapper::get();
		const native_handle_t* outHandle;
		status_t ret =
		mapper.importBuffer(buffer_node->bufferHandle(), buffer_node->bufferDesc().width,
		buffer_node->bufferDesc().height, buffer_node->bufferDesc().layers,
		buffer_node->bufferDesc().format, buffer_node->bufferDesc().usage,
		buffer_node->bufferDesc().stride, &outHandle);
		mapper.importBuffer(mBufferNode->bufferHandle(), mBufferNode->bufferDesc().width,
		mBufferNode->bufferDesc().height, mBufferNode->bufferDesc().layers,
		mBufferNode->bufferDesc().format, mBufferNode->bufferDesc().usage,
		mBufferNode->bufferDesc().stride, &outHandle);
		EXPECT_EQ(ret, OK);
		EXPECT_THAT(outHandle, NotNull());
		}

		TEST_F(BufferNodeTest, TestaddNewActiveClientsBitToMask_twoNewClients) {
		uint32_t new_client_state_mask_1 = buffer_node->addNewActiveClientsBitToMask();
		EXPECT_EQ(buffer_node->getActiveClientsBitMask(), new_client_state_mask_1);
		uint32_t newClientStateMask1 = mBufferNode->addNewActiveClientsBitToMask();
		EXPECT_EQ(mBufferNode->getActiveClientsBitMask(), newClientStateMask1);

		// Request and add a new client_state_mask again.
		// Active clients bit mask should be the union of the two new
		// client_state_masks.
		uint32_t new_client_state_mask_2 = buffer_node->addNewActiveClientsBitToMask();
		EXPECT_EQ(buffer_node->getActiveClientsBitMask(),
		new_client_state_mask_1 \| new_client_state_mask_2);
		uint32_t newClientStateMask2 = mBufferNode->addNewActiveClientsBitToMask();
		EXPECT_EQ(mBufferNode->getActiveClientsBitMask(), newClientStateMask1 \| newClientStateMask2);
		}

		TEST_F(BufferNodeTest, TestaddNewActiveClientsBitToMask_32NewClients) {
		uint32_t new_client_state_mask = 0U;
		uint32_t current_mask = 0U;
		uint32_t expected_mask = 0U;
		uint32_t newClientStateMask = 0U;
		uint32_t currentMask = 0U;
		uint32_t expectedMask = 0U;

		for (int i = 0; i < BufferHubDefs::kMaxNumberOfClients; ++i) {
		new_client_state_mask = buffer_node->addNewActiveClientsBitToMask();
		EXPECT_NE(new_client_state_mask, 0U);
		EXPECT_FALSE(new_client_state_mask & current_mask);
		expected_mask = current_mask \| new_client_state_mask;
		current_mask = buffer_node->getActiveClientsBitMask();
		EXPECT_EQ(current_mask, expected_mask);
		newClientStateMask = mBufferNode->addNewActiveClientsBitToMask();
		EXPECT_NE(newClientStateMask, 0U);
		EXPECT_FALSE(newClientStateMask & currentMask);
		expectedMask = currentMask \| newClientStateMask;
		currentMask = mBufferNode->getActiveClientsBitMask();
		EXPECT_EQ(currentMask, expectedMask);
		}

		// Method should fail upon requesting for more than maximum allowable clients.
		new_client_state_mask = buffer_node->addNewActiveClientsBitToMask();
		EXPECT_EQ(new_client_state_mask, 0U);
		newClientStateMask = mBufferNode->addNewActiveClientsBitToMask();
		EXPECT_EQ(newClientStateMask, 0U);
		EXPECT_EQ(errno, E2BIG);
		}

		TEST_F(BufferNodeTest, TestRemoveActiveClientsBitFromMask) {
		buffer_node->addNewActiveClientsBitToMask();
		uint32_t current_mask = buffer_node->getActiveClientsBitMask();
		uint32_t new_client_state_mask = buffer_node->addNewActiveClientsBitToMask();
		EXPECT_NE(buffer_node->getActiveClientsBitMask(), current_mask);
		mBufferNode->addNewActiveClientsBitToMask();
		uint32_t currentMask = mBufferNode->getActiveClientsBitMask();
		uint32_t newClientStateMask = mBufferNode->addNewActiveClientsBitToMask();
		EXPECT_NE(mBufferNode->getActiveClientsBitMask(), currentMask);

		buffer_node->removeClientsBitFromMask(new_client_state_mask);
		EXPECT_EQ(buffer_node->getActiveClientsBitMask(), current_mask);
		mBufferNode->removeClientsBitFromMask(newClientStateMask);
		EXPECT_EQ(mBufferNode->getActiveClientsBitMask(), currentMask);

		// Remove the test_mask again to the active client bit mask should not modify
		// the value of active clients bit mask.
		buffer_node->removeClientsBitFromMask(new_client_state_mask);
		EXPECT_EQ(buffer_node->getActiveClientsBitMask(), current_mask);
		mBufferNode->removeClientsBitFromMask(newClientStateMask);
		EXPECT_EQ(mBufferNode->getActiveClientsBitMask(), currentMask);
		}

		} // namespace

services/bufferhub/include/bufferhub/BufferClient.h

+1 −1

File changed.

Contains only whitespace changes.