Snap for 10900817 from 3891d995bb6458f557aa9a79b2f1ab29fbeabaec to sdk-release

Change-Id: I76859676513b843bb40996fe7d64a697075d08fc
diff --git a/fuzzer/Android.bp b/fuzzer/Android.bp
index 72d99d4..ee7afb9 100644
--- a/fuzzer/Android.bp
+++ b/fuzzer/Android.bp
@@ -51,6 +51,7 @@
         libfuzzer_options: [
             "max_len=50000",
         ],
+        use_for_presubmit: true
     },
 
     host_supported: true,
diff --git a/fuzzer/fmq_fuzzer.cpp b/fuzzer/fmq_fuzzer.cpp
index 8c8a78e..5f63908 100644
--- a/fuzzer/fmq_fuzzer.cpp
+++ b/fuzzer/fmq_fuzzer.cpp
@@ -44,7 +44,8 @@
  * to set a reasonable limit if we want to avoid those asserts.
  */
 static constexpr size_t kAlignment = 8;
-static constexpr size_t kMaxNumElements = PAGE_SIZE * 10 / sizeof(payload_t) - kAlignment + 1;
+static const size_t kPageSize = getpagesize();
+static const size_t kMaxNumElements = kPageSize * 10 / sizeof(payload_t) - kAlignment + 1;
 
 /*
  * The read counter can be found in the shared memory 16 bytes before the start
diff --git a/include/fmq/AidlMessageQueue.h b/include/fmq/AidlMessageQueue.h
index 0536d6a..bb56a32 100644
--- a/include/fmq/AidlMessageQueue.h
+++ b/include/fmq/AidlMessageQueue.h
@@ -144,10 +144,10 @@
             ints.push_back(shim->handle()->data[data_index]);
         }
         return MQDescriptor<T, U>{
-                .quantum = static_cast<int32_t>(shim->getQuantum()),
                 .grantors = grantors,
-                .flags = static_cast<int32_t>(shim->getFlags()),
                 .handle = {std::move(fds), std::move(ints)},
+                .quantum = static_cast<int32_t>(shim->getQuantum()),
+                .flags = static_cast<int32_t>(shim->getFlags()),
         };
     } else {
         return MQDescriptor<T, U>();
diff --git a/include/fmq/MessageQueueBase.h b/include/fmq/MessageQueueBase.h
index f4bf7e2..ca8e838 100644
--- a/include/fmq/MessageQueueBase.h
+++ b/include/fmq/MessageQueueBase.h
@@ -455,6 +455,8 @@
      * lifetime.
      */
     android::hardware::EventFlag* mEventFlag = nullptr;
+
+    const size_t kPageSize = getpagesize();
 };
 
 template <template <typename, MQFlavor> typename MQDescriptorType, typename T, MQFlavor flavor>
@@ -689,12 +691,12 @@
     if (bufferFd != -1) {
         // Allocate read counter and write counter only. User-supplied memory will be used for the
         // ringbuffer.
-        kAshmemSizePageAligned = (kMetaDataSize + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
+        kAshmemSizePageAligned = (kMetaDataSize + kPageSize - 1) & ~(kPageSize - 1);
     } else {
         // Allocate ringbuffer, read counter and write counter.
         kAshmemSizePageAligned = (hardware::details::alignToWordBoundary(kQueueSizeBytes) +
-                                  kMetaDataSize + PAGE_SIZE - 1) &
-                                 ~(PAGE_SIZE - 1);
+                                  kMetaDataSize + kPageSize - 1) &
+                                 ~(kPageSize - 1);
     }
 
     /*
@@ -1269,7 +1271,7 @@
     }
 
     /*
-     * Offset for mmap must be a multiple of PAGE_SIZE.
+     * Offset for mmap must be a multiple of kPageSize.
      */
     if (!hardware::details::isAlignedToWordBoundary(grantors[grantorIdx].offset)) {
         hardware::details::logError("Grantor (index " + std::to_string(grantorIdx) +
@@ -1278,8 +1280,8 @@
         return nullptr;
     }
 
-    int mapOffset = (grantors[grantorIdx].offset / PAGE_SIZE) * PAGE_SIZE;
-    if (grantors[grantorIdx].extent < 0 || grantors[grantorIdx].extent > INT_MAX - PAGE_SIZE) {
+    int mapOffset = (grantors[grantorIdx].offset / kPageSize) * kPageSize;
+    if (grantors[grantorIdx].extent < 0 || grantors[grantorIdx].extent > INT_MAX - kPageSize) {
         hardware::details::logError(std::string("Grantor (index " + std::to_string(grantorIdx) +
                                                 ") extent value is too large or negative: " +
                                                 std::to_string(grantors[grantorIdx].extent)));
@@ -1304,7 +1306,7 @@
         return;
     }
 
-    int mapOffset = (grantors[grantorIdx].offset / PAGE_SIZE) * PAGE_SIZE;
+    int mapOffset = (grantors[grantorIdx].offset / kPageSize) * kPageSize;
     int mapLength = grantors[grantorIdx].offset - mapOffset + grantors[grantorIdx].extent;
     void* baseAddress =
             reinterpret_cast<uint8_t*>(address) - (grantors[grantorIdx].offset - mapOffset);
diff --git a/tests/fmq_unit_tests.cpp b/tests/fmq_unit_tests.cpp
index 03db6ec..08790c8 100644
--- a/tests/fmq_unit_tests.cpp
+++ b/tests/fmq_unit_tests.cpp
@@ -376,7 +376,8 @@
 
 // If this test fails and we do leak FDs, the next test will cause a crash
 TEST_F(AidlOnlyBadQueueConfig, LookForLeakedFds) {
-    size_t numElementsInQueue = SIZE_MAX / sizeof(uint32_t) - PAGE_SIZE - 1;
+    const size_t kPageSize = getpagesize();
+    size_t numElementsInQueue = SIZE_MAX / sizeof(uint32_t) - kPageSize - 1;
     struct rlimit rlim;
     ASSERT_EQ(getrlimit(RLIMIT_NOFILE, &rlim), 0);
     for (int i = 0; i <= rlim.rlim_cur + 1; i++) {
diff --git a/tests/msgq_test_client.cpp b/tests/msgq_test_client.cpp
index 1ff9d50..b55c368 100644
--- a/tests/msgq_test_client.cpp
+++ b/tests/msgq_test_client.cpp
@@ -61,7 +61,8 @@
 typedef android::hardware::MessageQueue<int32_t, kSynchronizedReadWrite> MessageQueueSync;
 typedef android::hardware::MessageQueue<int32_t, kUnsynchronizedWrite> MessageQueueUnsync;
 static const std::string kServiceName = "BnTestAidlMsgQ";
-static constexpr size_t kNumElementsInSyncQueue = (PAGE_SIZE - 16) / sizeof(int32_t);
+static const size_t kPageSize = getpagesize();
+static const size_t kNumElementsInSyncQueue = (kPageSize - 16) / sizeof(int32_t);
 
 enum class SetupType {
     SINGLE_FD,
@@ -425,7 +426,7 @@
         ASSERT_TRUE(ret);
     }
     {
-        std::array<int32_t, kNumElementsInSyncQueue> data = {0};
+        std::vector<int32_t> data(kNumElementsInSyncQueue, 0);
         ret = this->mQueue->writeBlocking(
                 data.data(), data.size(),
                 static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
@@ -464,7 +465,7 @@
      * kNumElementsInSyncQueue will succeed.
      */
     {
-        std::array<int32_t, kNumElementsInSyncQueue> data = {0};
+        std::vector<int32_t> data(kNumElementsInSyncQueue, 0);
         ret = this->mQueue->writeBlocking(data.data(), data.size(), 5000000000 /* timeOutNanos */);
         ASSERT_TRUE(ret);
     }
@@ -505,7 +506,7 @@
      * blocking write should be successful.
      */
     {
-        std::array<int32_t, kNumElementsInSyncQueue> data = {0};
+        std::vector<int32_t> data(kNumElementsInSyncQueue, 0);
         ret = this->mQueue->writeBlocking(
                 data.data(), data.size(),
                 static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
@@ -551,7 +552,7 @@
      * blocking write should be successful.
      */
     {
-        std::array<int32_t, kNumElementsInSyncQueue> data = {0};
+        std::vector<int32_t> data(kNumElementsInSyncQueue, 0);
         ret = this->mQueue->writeBlocking(
                 data.data(), data.size(),
                 static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
@@ -596,7 +597,7 @@
      * blocking write should be successful.
      */
     {
-        std::array<int32_t, kNumElementsInSyncQueue> data = {0};
+        std::vector<int32_t> data(kNumElementsInSyncQueue, 0);
         ret = this->mQueue->writeBlocking(
                 data.data(), data.size(),
                 static_cast<uint32_t>(ITestMsgQ::EventFlagBits::FMQ_NOT_FULL),
@@ -789,7 +790,7 @@
  * to read and verify the messages in the FMQ.
  */
 TYPED_TEST(SynchronizedReadWriteClient, WriteWhenFull) {
-    std::array<int32_t, kNumElementsInSyncQueue> data = {0};
+    std::vector<int32_t> data(kNumElementsInSyncQueue, 0);
     initData(data.data(), data.size());
     ASSERT_TRUE(this->mQueue->write(data.data(), data.size()));
     ASSERT_EQ(0UL, this->mQueue->availableToWrite());
@@ -836,7 +837,7 @@
  */
 
 TYPED_TEST(SynchronizedReadWriteClient, LargeInputTest3) {
-    std::array<int32_t, kNumElementsInSyncQueue> data = {0};
+    std::vector<int32_t> data(kNumElementsInSyncQueue, 0);
     initData(data.data(), data.size());
     ASSERT_TRUE(this->mQueue->write(data.data(), data.size()));
     ASSERT_EQ(0UL, this->mQueue->availableToWrite());
@@ -894,7 +895,7 @@
  */
 TYPED_TEST(SynchronizedReadWriteClient, ReadWriteWrapAround) {
     size_t numMessages = kNumElementsInSyncQueue / 2;
-    std::array<int32_t, kNumElementsInSyncQueue> data = {0};
+    std::vector<int32_t> data(kNumElementsInSyncQueue, 0);
     initData(data.data(), data.size());
     ASSERT_TRUE(this->mQueue->write(&data[0], numMessages));
     bool ret = this->requestReadFmqSync(numMessages);
@@ -914,7 +915,7 @@
  */
 TYPED_TEST(SynchronizedReadWriteClient, ReadWriteWrapAround2) {
     size_t numMessages = kNumElementsInSyncQueue / 2;
-    std::array<int32_t, kNumElementsInSyncQueue> data = {0};
+    std::vector<int32_t> data(kNumElementsInSyncQueue, 0);
     initData(data.data(), data.size());
     ASSERT_TRUE(this->mQueue->write(&data[0], numMessages));
     auto ret = this->requestReadFmqSync(numMessages);