refactor(container): use span instead of data+size in async_byte_queue

Author: strager

src/quick-lint-js/container/async-byte-queue.cpp

@@ -7,6 +7,7 @@
 #include <cstring>
 #include <quick-lint-js/container/async-byte-queue.h>
 #include <quick-lint-js/port/memory-resource.h>
+#include <quick-lint-js/port/span.h>
 #include <quick-lint-js/port/thread.h>
 #include <quick-lint-js/util/narrow-cast.h>
 #include <quick-lint-js/util/pointer.h>
@@ -52,8 +53,9 @@ void async_byte_queue::commit() {
 string8 async_byte_queue::take_committed_string8() {
   string8 result;
   this->take_committed(
-      [&result](const std::byte* data, std::size_t size) -> void {
-        result.append(reinterpret_cast<const char8*>(data), size);
+      [&result](span<const std::byte> data) -> void {
+        result.append(reinterpret_cast<const char8*>(data.data()),
+                      narrow_cast<std::size_t>(data.size()));
       },
       []() {});
   return result;

src/quick-lint-js/container/async-byte-queue.h

@@ -9,7 +9,9 @@
 #include <quick-lint-js/port/char8.h>
 #include <quick-lint-js/port/max-align.h>
 #include <quick-lint-js/port/memory-resource.h>
+#include <quick-lint-js/port/span.h>
 #include <quick-lint-js/port/thread.h>
+#include <quick-lint-js/util/narrow-cast.h>
 #include <utility>
 
 namespace quick_lint_js {
@@ -148,9 +150,9 @@ void async_byte_queue::take_committed(ChunkFunc&& chunk_callback,
   chunk* last_chunk;
   {
     std::unique_lock<mutex> lock(this->mutex_);
-    auto call_chunk_callback = [&](const std::byte* data, size_type size) {
+    auto call_chunk_callback = [&](span<const std::byte> data) {
       lock.unlock();
-      chunk_callback(data, size);
+      chunk_callback(data);
       lock.lock();
     };
 
@@ -161,8 +163,9 @@ void async_byte_queue::take_committed(ChunkFunc&& chunk_callback,
     // NOTE[committed_index-data_size].
     while (c->next) {
       size_type old_data_size = c->data_size;
-      call_chunk_callback(&c->capacity_begin()[c->begin_index],
-                          c->data_size - c->begin_index);
+      call_chunk_callback(span<const std::byte>(
+          &c->capacity_begin()[c->begin_index],
+          narrow_cast<span_size>(c->data_size - c->begin_index)));
 
       // These shouldn't be changed by the callback or by the writer thread.
       QLJS_ASSERT(c->data_size == old_data_size);
@@ -172,8 +175,9 @@ void async_byte_queue::take_committed(ChunkFunc&& chunk_callback,
     }
 
     size_type old_committed_index = c->committed_index;
-    call_chunk_callback(&c->capacity_begin()[c->begin_index],
-                        old_committed_index - c->begin_index);
+    call_chunk_callback(span<const std::byte>(
+        &c->capacity_begin()[c->begin_index],
+        narrow_cast<span_size>(old_committed_index - c->begin_index)));
     c->begin_index = old_committed_index;
     // NOTE(strager): Because call_chunk_callback unlocks the mutex,
     // c->committed_index and c->next might change.

src/quick-lint-js/debug/debug-server.cpp

@@ -70,15 +70,16 @@ class trace_flusher_websocket_backend final : public trace_flusher_backend {
       }
 
       queue.take_committed(
-          [&](const std::byte *data, std::size_t size) {
+          [&](span<const std::byte> data) {
             // FIXME(strager): ::mg_send fails if size is 0. We shouldn't need
             // this size check, but async_byte_queue gives us empty chunks for
             // some reason. We should make async_byte_queue not give us empty
             // chunks.
-            if (size > 0) {
-              int ok = ::mg_send(this->connection_, data, size);
+            if (!data.empty()) {
+              int ok = ::mg_send(this->connection_, data.data(),
+                                 narrow_cast<std::size_t>(data.size()));
               QLJS_ASSERT(ok);
-              total_message_size += size;
+              total_message_size += narrow_cast<std::size_t>(data.size());
             }
           },
           [] {});

src/quick-lint-js/logging/trace-flusher.cpp

@@ -217,11 +217,9 @@ void trace_flusher::flush_one_thread_sync(std::unique_lock<mutex>&,
                                           registered_thread& t) {
   // TODO(strager): Use writev if supported.
   t.stream_queue.take_committed(
-      [&](const std::byte* data, std::size_t size) {
+      [&](span<const std::byte> data) {
         for (trace_flusher_backend* backend : this->backends_) {
-          backend->trace_thread_write_data(
-              t.thread_index,
-              span<const std::byte>(data, narrow_cast<span_size>(size)));
+          backend->trace_thread_write_data(t.thread_index, data);
         }
       },
       [] {});
@@ -257,10 +255,8 @@ void trace_flusher::write_thread_header_to_backend(
   });
   temp_queue.commit();
   temp_queue.take_committed(
-      [&](const std::byte* data, std::size_t size) {
-        backend->trace_thread_write_data(
-            t.thread_index,
-            span<const std::byte>(data, narrow_cast<span_size>(size)));
+      [&](span<const std::byte> data) {
+        backend->trace_thread_write_data(t.thread_index, data);
       },
       [] {});
 }

test/test-async-byte-queue.cpp

@@ -213,30 +213,24 @@ TEST(test_async_byte_queue,
   std::fill_n(chunk_2, q.default_chunk_size, u8'c');
   q.commit();
 
-  struct chunk {
-    const std::byte* data;
-    async_byte_queue::size_type size;
-  };
-  std::vector<chunk> chunks;
+  std::vector<span<const std::byte>> chunks;
   bool finalize_called = false;
   q.take_committed(
-      [&](const std::byte* data, async_byte_queue::size_type size) {
-        chunks.push_back(chunk{.data = data, .size = size});
-      },
+      [&](span<const std::byte> data) { chunks.push_back(data); },
       [&]() {
         ASSERT_EQ(chunks.size(), 3);
 
-        EXPECT_EQ(chunks[0].size, q.default_chunk_size);
-        EXPECT_EQ(chunks[0].data, reinterpret_cast<std::byte*>(chunk_0));
-        EXPECT_EQ(static_cast<char8>(chunks[0].data[0]), u8'a');
+        EXPECT_EQ(chunks[0].size(), q.default_chunk_size);
+        EXPECT_EQ(chunks[0].data(), reinterpret_cast<std::byte*>(chunk_0));
+        EXPECT_EQ(static_cast<char8>(chunks[0][0]), u8'a');
 
-        EXPECT_EQ(chunks[1].size, q.default_chunk_size);
-        EXPECT_EQ(chunks[1].data, reinterpret_cast<std::byte*>(chunk_1));
-        EXPECT_EQ(static_cast<char8>(chunks[1].data[0]), u8'b');
+        EXPECT_EQ(chunks[1].size(), q.default_chunk_size);
+        EXPECT_EQ(chunks[1].data(), reinterpret_cast<std::byte*>(chunk_1));
+        EXPECT_EQ(static_cast<char8>(chunks[1][0]), u8'b');
 
-        EXPECT_EQ(chunks[2].size, q.default_chunk_size / 4);
-        EXPECT_EQ(chunks[2].data, reinterpret_cast<std::byte*>(chunk_2));
-        EXPECT_EQ(static_cast<char8>(chunks[2].data[0]), u8'c');
+        EXPECT_EQ(chunks[2].size(), q.default_chunk_size / 4);
+        EXPECT_EQ(chunks[2].data(), reinterpret_cast<std::byte*>(chunk_2));
+        EXPECT_EQ(static_cast<char8>(chunks[2][0]), u8'c');
 
         finalize_called = true;
       });