1 files changed, 20 insertions, 20 deletions

diff --git a/apps/test/chqts/src/shared/send_message.cc b/apps/test/chqts/src/shared/send_message.cc
index 56ec3b73..f4641780 100644
--- a/apps/test/chqts/src/shared/send_message.cc
+++ b/apps/test/chqts/src/shared/send_message.cc
@@ -19,7 +19,7 @@
 #include <inttypes.h>
 
 #include <shared/abort.h>
-#include <shared/chunk_allocator.h>
+#include <shared/dumb_allocator.h>
 #include <shared/nano_endian.h>
 #include <shared/nano_string.h>
 
@@ -29,27 +29,27 @@ namespace nanoapp_testing {
 
 constexpr size_t kAllocSize = 128;
 
-static ChunkAllocator<kAllocSize, 4> gChunkAlloc;
+static DumbAllocator<kAllocSize, 4> gDumbAlloc;
 
-static void freeChunkAllocMessage(void *message, size_t messageSize) {
+static void freeDumbAllocMessage(void *message, size_t messageSize) {
   if (messageSize > kAllocSize) {
     uint32_t localSize = uint32_t(messageSize);
-    sendFatalFailureToHost("freeChunkAllocMessage given oversized message:",
+    sendFatalFailureToHost("freeDumbAllocMessage given oversized message:",
                            &localSize);
   }
-  if (!gChunkAlloc.free(message)) {
+  if (!gDumbAlloc.free(message)) {
     uint32_t localPtr =
         reinterpret_cast<size_t>(message) & UINT32_C(0xFFFFFFFF);
-    sendFatalFailureToHost("freeChunkAllocMessage given bad pointer:",
+    sendFatalFailureToHost("freeDumbAllocMessage given bad pointer:",
                            &localPtr);
   }
 }
 
 static void freeHeapMessage(void *message, size_t /* messageSize */) {
-  if (gChunkAlloc.contains(message)) {
+  if (gDumbAlloc.contains(message)) {
     uint32_t localPtr =
         reinterpret_cast<size_t>(message) & UINT32_C(0xFFFFFFFF);
-    sendFatalFailureToHost("freeHeapMessage given ChunkAlloc pointer:",
+    sendFatalFailureToHost("freeHeapMessage given DumbAlloc pointer:",
                            &localPtr);
   }
   chreHeapFree(message);
@@ -74,17 +74,17 @@ static bool needToPrependMessageType() {
   return true;
 }
 
-static void *getMessageMemory(size_t *size, bool *ChunkAlloc) {
+static void *getMessageMemory(size_t *size, bool *dumbAlloc) {
   if (needToPrependMessageType()) {
     *size += sizeof(uint32_t);
   }
-  void *ret = gChunkAlloc.alloc(*size);
+  void *ret = gDumbAlloc.alloc(*size);
   if (ret != nullptr) {
-    *ChunkAlloc = true;
+    *dumbAlloc = true;
   } else {
     // Not expected, but possible if the CHRE is lagging in freeing
     // these messages, or if we're sending a huge message.
-    *ChunkAlloc = false;
+    *dumbAlloc = false;
     ret = chreHeapAlloc(static_cast<uint32_t>(*size));
     if (ret == nullptr) {
       fatalError();
@@ -107,14 +107,14 @@ static void *prependMessageType(MessageType messageType, void *memory) {
 }
 
 static void internalSendMessage(MessageType messageType, void *data,
-                                size_t dataSize, bool ChunkAlloc) {
+                                size_t dataSize, bool dumbAlloc) {
   // Note that if the CHRE implementation occasionally drops a message
   // here, then tests will become flaky.  For now, we consider that to
   // be a flaky CHRE implementation which should fail testing.
   if (!chreSendMessageToHostEndpoint(
           data, dataSize, static_cast<uint32_t>(messageType),
           CHRE_HOST_ENDPOINT_BROADCAST,
-          ChunkAlloc ? freeChunkAllocMessage : freeHeapMessage)) {
+          dumbAlloc ? freeDumbAllocMessage : freeHeapMessage)) {
     fatalError();
   }
 }
@@ -124,12 +124,12 @@ void sendMessageToHost(MessageType messageType, const void *data,
   if ((dataSize == 0) && (data != nullptr)) {
     sendInternalFailureToHost("Bad sendMessageToHost args");
   }
-  bool ChunkAlloc = true;
+  bool dumbAlloc = true;
   size_t fullMessageSize = dataSize;
-  void *myMessageBase = getMessageMemory(&fullMessageSize, &ChunkAlloc);
+  void *myMessageBase = getMessageMemory(&fullMessageSize, &dumbAlloc);
   void *ptr = prependMessageType(messageType, myMessageBase);
   memcpy(ptr, data, dataSize);
-  internalSendMessage(messageType, myMessageBase, fullMessageSize, ChunkAlloc);
+  internalSendMessage(messageType, myMessageBase, fullMessageSize, dumbAlloc);
 }
 
 void sendStringToHost(MessageType messageType, const char *message,
@@ -137,7 +137,7 @@ void sendStringToHost(MessageType messageType, const char *message,
   if (message == nullptr) {
     sendInternalFailureToHost("sendStringToHost 'message' is NULL");
   }
-  bool ChunkAlloc = true;
+  bool dumbAlloc = true;
   const size_t messageStrlen = strlen(message);
   size_t myMessageLen = messageStrlen;
   if (value != nullptr) {
@@ -148,7 +148,7 @@ void sendStringToHost(MessageType messageType, const char *message,
 
   size_t fullMessageLen = myMessageLen;
   char *fullMessage =
-      static_cast<char *>(getMessageMemory(&fullMessageLen, &ChunkAlloc));
+      static_cast<char *>(getMessageMemory(&fullMessageLen, &dumbAlloc));
   char *ptr = static_cast<char *>(prependMessageType(messageType, fullMessage));
   memcpy(ptr, message, messageStrlen);
   ptr += messageStrlen;
@@ -159,7 +159,7 @@ void sendStringToHost(MessageType messageType, const char *message,
   // Add the terminator.
   fullMessage[fullMessageLen - 1] = '\0';
 
-  internalSendMessage(messageType, fullMessage, fullMessageLen, ChunkAlloc);
+  internalSendMessage(messageType, fullMessage, fullMessageLen, dumbAlloc);
 }
 
 // Before we abort the nanoapp, we also put this message in the chreLog().