diff --git a/components/webrtc_logging/common/partial_circular_buffer.cc b/components/webrtc_logging/common/partial_circular_buffer.cc
index 978f82d26a315..1662c3db71dc8 100644
--- a/components/webrtc_logging/common/partial_circular_buffer.cc
+++ b/components/webrtc_logging/common/partial_circular_buffer.cc
@@ -8,7 +8,7 @@
 #include <cstring>
 
 #include "base/check_op.h"
-#include "base/compiler_specific.h"
+#include "base/containers/span.h"
 
 namespace webrtc_logging {
 
@@ -56,20 +56,23 @@ PartialCircularBuffer::PartialCircularBuffer(void* buffer,
   }
 }
 
-uint32_t PartialCircularBuffer::Read(void* buffer, uint32_t buffer_size) {
+uint32_t PartialCircularBuffer::Read(base::span<uint8_t> buffer) {
   DCHECK(buffer_data_);
   if (total_read_ >= buffer_data_->total_written)
     return 0;
 
-  uint8_t* buffer_uint8 = reinterpret_cast<uint8_t*>(buffer);
   uint32_t read = 0;
 
   // Read from beginning part.
   if (position_ < buffer_data_->wrap_position) {
     uint32_t to_wrap_pos = buffer_data_->wrap_position - position_;
     uint32_t to_eow = buffer_data_->total_written - total_read_;
-    uint32_t to_read = std::min({buffer_size, to_wrap_pos, to_eow});
-    UNSAFE_TODO(memcpy(buffer_uint8, buffer_data_->data + position_, to_read));
+    uint32_t to_read = std::min({(uint32_t)buffer.size(), to_wrap_pos, to_eow});
+    // SAFETY: The constructor checks that `data_size_` is a valid size for
+    // `buffer_data_->data`.
+    buffer.first(to_read).copy_from(
+        UNSAFE_BUFFERS(base::span(buffer_data_->data, data_size_))
+            .subspan(position_, to_read));
     position_ += to_read;
     total_read_ += to_read;
     read += to_read;
@@ -80,8 +83,8 @@ uint32_t PartialCircularBuffer::Read(void* buffer, uint32_t buffer_size) {
       // writing has wrapped.)
       position_ = buffer_data_->end_position;
     }
-    if (read >= buffer_size) {
-      DCHECK_EQ(read, buffer_size);
+    if (read >= buffer.size()) {
+      DCHECK_EQ(read, buffer.size());
       return read;
     }
     if (read >= to_eow) {
@@ -94,12 +97,15 @@ uint32_t PartialCircularBuffer::Read(void* buffer, uint32_t buffer_size) {
   // Read from middle part.
   DCHECK_GE(position_, buffer_data_->wrap_position);
   if (position_ >= buffer_data_->end_position) {
-    uint32_t remaining_buffer_size = buffer_size - read;
+    uint32_t remaining_buffer_size = buffer.size() - read;
     uint32_t to_eof = data_size_ - position_;
     uint32_t to_eow = buffer_data_->total_written - total_read_;
     uint32_t to_read = std::min({remaining_buffer_size, to_eof, to_eow});
-    UNSAFE_TODO(
-        memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read));
+    // SAFETY: The constructor checks that `data_size_` is a valid size for
+    // `buffer_data_->data`.
+    buffer.subspan(read, to_read)
+        .copy_from(UNSAFE_BUFFERS(base::span(buffer_data_->data, data_size_))
+                       .subspan(position_, to_read));
     position_ += to_read;
     total_read_ += to_read;
     read += to_read;
@@ -107,8 +113,8 @@ uint32_t PartialCircularBuffer::Read(void* buffer, uint32_t buffer_size) {
       // We've read all the middle part, set position to the end part.
       position_ = buffer_data_->wrap_position;
     }
-    if (read >= buffer_size) {
-      DCHECK_EQ(read, buffer_size);
+    if (read >= buffer.size()) {
+      DCHECK_EQ(read, buffer.size());
       return read;
     }
     if (total_read_ >= buffer_data_->total_written) {
@@ -120,16 +126,19 @@ uint32_t PartialCircularBuffer::Read(void* buffer, uint32_t buffer_size) {
   // Read from end part.
   DCHECK_GE(position_, buffer_data_->wrap_position);
   DCHECK_LT(position_, buffer_data_->end_position);
-  uint32_t remaining_buffer_size = buffer_size - read;
+  uint32_t remaining_buffer_size = buffer.size() - read;
   uint32_t to_eob = buffer_data_->end_position - position_;
   uint32_t to_eow = buffer_data_->total_written - total_read_;
   uint32_t to_read = std::min({remaining_buffer_size, to_eob, to_eow});
-  UNSAFE_TODO(
-      memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read));
+  // SAFETY: The constructor checks that `data_size_` is a valid size for
+  // `buffer_data_->data`.
+  buffer.subspan(read, to_read)
+      .copy_from(UNSAFE_BUFFERS(base::span(buffer_data_->data, data_size_))
+                     .subspan(position_, to_read));
   position_ += to_read;
   total_read_ += to_read;
   read += to_read;
-  DCHECK_LE(read, buffer_size);
+  DCHECK_LE(read, buffer.size());
   DCHECK_LE(total_read_, buffer_data_->total_written);
   return read;
 }
diff --git a/components/webrtc_logging/common/partial_circular_buffer.h b/components/webrtc_logging/common/partial_circular_buffer.h
index 9da196dbe2066..dbffd8629f336 100644
--- a/components/webrtc_logging/common/partial_circular_buffer.h
+++ b/components/webrtc_logging/common/partial_circular_buffer.h
@@ -9,6 +9,8 @@
 
 #include "base/memory/raw_ptr.h"
 
+#include "base/containers/span.h"
+
 namespace webrtc_logging {
 
 // A wrapper around a memory buffer that allows circular read and write with a
@@ -39,7 +41,7 @@ class PartialCircularBuffer {
                         uint32_t wrap_position,
                         bool append);
 
-  uint32_t Read(void* buffer, uint32_t buffer_size);
+  uint32_t Read(base::span<uint8_t> buffer);
   void Write(const void* buffer, uint32_t buffer_size);
 
  private:
diff --git a/components/webrtc_logging/common/partial_circular_buffer_unittest.cc b/components/webrtc_logging/common/partial_circular_buffer_unittest.cc
index da76aa2a5e76e..d5610e7409207 100644
--- a/components/webrtc_logging/common/partial_circular_buffer_unittest.cc
+++ b/components/webrtc_logging/common/partial_circular_buffer_unittest.cc
@@ -12,6 +12,7 @@
 // Note that desipte the number of wraps (if one or more), the reference output
 // data is the same since the offset at each wrap is always the same.
 
+#include <array>
 #include "components/webrtc_logging/common/partial_circular_buffer.h"
 
 #include <stddef.h>
@@ -19,6 +20,8 @@
 
 #include <memory>
 
+#include "base/containers/auto_spanification_helper.h"
+#include "base/containers/span.h"
 #include "base/compiler_specific.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -80,14 +83,13 @@ TEST_F(PartialCircularBufferTest, NoWrapBeginningPartOnly) {
   WriteToBuffer(1);
   InitReadBuffer();
 
-  uint8_t output_data[sizeof(kInputData)] = {};
-  EXPECT_EQ(sizeof(output_data),
-            pcb_read_->Read(output_data, sizeof(output_data)));
+  std::array<uint8_t, sizeof(kInputData)> output_data = {};
+  EXPECT_EQ(sizeof(output_data), pcb_read_->Read(output_data));
 
-  UNSAFE_TODO(
-      EXPECT_EQ(0, memcmp(kInputData, output_data, sizeof(kInputData))));
+  EXPECT_TRUE(std::equal(std::begin(kInputData), std::end(kInputData),
+                         output_data.begin()));
 
-  EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data)));
+  EXPECT_EQ(0u, pcb_read_->Read(output_data));
 }
 
 TEST_F(PartialCircularBufferTest, NoWrapBeginningAndEndParts) {
@@ -95,17 +97,16 @@ TEST_F(PartialCircularBufferTest, NoWrapBeginningAndEndParts) {
   WriteToBuffer(2);
   InitReadBuffer();
 
-  uint8_t output_data[2 * sizeof(kInputData)] = {};
-  EXPECT_EQ(sizeof(output_data),
-            pcb_read_->Read(output_data, sizeof(output_data)));
+  std::array<uint8_t, 2 * sizeof(kInputData)> output_data = {};
+  EXPECT_EQ(sizeof(output_data), pcb_read_->Read(output_data));
 
   const uint8_t output_ref_data[2 * sizeof(kInputData)] = {
       1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
       1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
-  UNSAFE_TODO(
-      EXPECT_EQ(0, memcmp(output_ref_data, output_data, sizeof(output_data))));
+  EXPECT_TRUE(std::equal(std::begin(output_ref_data), std::end(output_ref_data),
+                         output_data.begin()));
 
-  EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data)));
+  EXPECT_EQ(0u, pcb_read_->Read(output_data));
 }
 
 TEST_F(PartialCircularBufferTest, WrapOnce) {
@@ -113,14 +114,13 @@ TEST_F(PartialCircularBufferTest, WrapOnce) {
   WriteToBuffer(4);
   InitReadBuffer();
 
-  uint8_t output_data[sizeof(kOutputRefDataWrap)] = {};
-  EXPECT_EQ(sizeof(output_data),
-            pcb_read_->Read(output_data, sizeof(output_data)));
+  std::array<uint8_t, sizeof(kOutputRefDataWrap)> output_data = {};
+  EXPECT_EQ(sizeof(output_data), pcb_read_->Read(output_data));
 
-  UNSAFE_TODO(EXPECT_EQ(
-      0, memcmp(kOutputRefDataWrap, output_data, sizeof(output_data))));
+  EXPECT_TRUE(std::equal(std::begin(kOutputRefDataWrap),
+                         std::end(kOutputRefDataWrap), output_data.begin()));
 
-  EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data)));
+  EXPECT_EQ(0u, pcb_read_->Read(output_data));
 }
 
 TEST_F(PartialCircularBufferTest, WrapTwice) {
@@ -128,14 +128,13 @@ TEST_F(PartialCircularBufferTest, WrapTwice) {
   WriteToBuffer(7);
   InitReadBuffer();
 
-  uint8_t output_data[sizeof(kOutputRefDataWrap)] = {};
-  EXPECT_EQ(sizeof(output_data),
-            pcb_read_->Read(output_data, sizeof(output_data)));
+  std::array<uint8_t, sizeof(kOutputRefDataWrap)> output_data = {};
+  EXPECT_EQ(sizeof(output_data), pcb_read_->Read(output_data));
 
-  UNSAFE_TODO(EXPECT_EQ(
-      0, memcmp(kOutputRefDataWrap, output_data, sizeof(output_data))));
+  EXPECT_TRUE(std::equal(std::begin(kOutputRefDataWrap),
+                         std::end(kOutputRefDataWrap), output_data.begin()));
 
-  EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data)));
+  EXPECT_EQ(0u, pcb_read_->Read(output_data));
 }
 
 TEST_F(PartialCircularBufferTest, WrapOnceSmallerOutputBuffer) {
@@ -143,20 +142,21 @@ TEST_F(PartialCircularBufferTest, WrapOnceSmallerOutputBuffer) {
   WriteToBuffer(4);
   InitReadBuffer();
 
-  uint8_t output_data[sizeof(kOutputRefDataWrap)] = {};
+  std::array<uint8_t, sizeof(kOutputRefDataWrap)> output_data = {};
   const uint32_t size_per_read = 16;
   uint32_t read = 0;
-  for (; read + size_per_read <= sizeof(output_data); read += size_per_read) {
-    UNSAFE_TODO(EXPECT_EQ(size_per_read,
-                          pcb_read_->Read(output_data + read, size_per_read)));
+  for (; read + size_per_read <= output_data.size(); read += size_per_read) {
+    EXPECT_EQ(size_per_read,
+              pcb_read_->Read(
+                  base::span(output_data).subspan(read, size_per_read)));
   }
-  UNSAFE_TODO(EXPECT_EQ(sizeof(output_data) - read,
-                        pcb_read_->Read(output_data + read, size_per_read)));
+  EXPECT_EQ(output_data.size() - read,
+            pcb_read_->Read(base::span(output_data).subspan(read)));
 
-  UNSAFE_TODO(EXPECT_EQ(
-      0, memcmp(kOutputRefDataWrap, output_data, sizeof(output_data))));
+  EXPECT_TRUE(std::equal(std::begin(kOutputRefDataWrap),
+                         std::end(kOutputRefDataWrap), output_data.begin()));
 
-  EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data)));
+  EXPECT_EQ(0u, pcb_read_->Read(output_data));
 }
 
 TEST_F(PartialCircularBufferTest, WrapOnceWithAppend) {
@@ -166,14 +166,13 @@ TEST_F(PartialCircularBufferTest, WrapOnceWithAppend) {
   WriteToBuffer(2);
   InitReadBuffer();
 
-  uint8_t output_data[sizeof(kOutputRefDataWrap)] = {};
-  EXPECT_EQ(sizeof(output_data),
-            pcb_read_->Read(output_data, sizeof(output_data)));
+  std::array<uint8_t, sizeof(kOutputRefDataWrap)> output_data = {};
+  EXPECT_EQ(sizeof(output_data), pcb_read_->Read(output_data));
 
-  UNSAFE_TODO(EXPECT_EQ(
-      0, memcmp(kOutputRefDataWrap, output_data, sizeof(output_data))));
+  EXPECT_TRUE(std::equal(std::begin(kOutputRefDataWrap),
+                         std::end(kOutputRefDataWrap), output_data.begin()));
 
-  EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data)));
+  EXPECT_EQ(0u, pcb_read_->Read(output_data));
 }
 
 TEST_F(PartialCircularBufferTest, WrapTwiceWithAppend) {
@@ -183,14 +182,13 @@ TEST_F(PartialCircularBufferTest, WrapTwiceWithAppend) {
   WriteToBuffer(3);
   InitReadBuffer();
 
-  uint8_t output_data[sizeof(kOutputRefDataWrap)] = {};
-  EXPECT_EQ(sizeof(output_data),
-            pcb_read_->Read(output_data, sizeof(output_data)));
+  std::array<uint8_t, sizeof(kOutputRefDataWrap)> output_data = {};
+  EXPECT_EQ(sizeof(output_data), pcb_read_->Read(output_data));
 
-  UNSAFE_TODO(EXPECT_EQ(
-      0, memcmp(kOutputRefDataWrap, output_data, sizeof(output_data))));
+  EXPECT_TRUE(std::equal(std::begin(kOutputRefDataWrap),
+                         std::end(kOutputRefDataWrap), output_data.begin()));
 
-  EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data)));
+  EXPECT_EQ(0u, pcb_read_->Read(output_data));
 }
 
 TEST_F(PartialCircularBufferTest, WrapOnceThenOverwriteWithNoWrap) {
@@ -200,35 +198,34 @@ TEST_F(PartialCircularBufferTest, WrapOnceThenOverwriteWithNoWrap) {
   WriteToBuffer(1);
   InitReadBuffer();
 
-  uint8_t output_data[sizeof(kInputData)] = {};
-  EXPECT_EQ(sizeof(output_data),
-            pcb_read_->Read(output_data, sizeof(output_data)));
+  std::array<uint8_t, sizeof(kInputData)> output_data = {};
+  EXPECT_EQ(sizeof(output_data), pcb_read_->Read(output_data));
 
-  UNSAFE_TODO(
-      EXPECT_EQ(0, memcmp(kInputData, output_data, sizeof(kInputData))));
+  EXPECT_TRUE(std::equal(std::begin(kInputData), std::end(kInputData),
+                         output_data.begin()));
 
-  EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data)));
+  EXPECT_EQ(0u, pcb_read_->Read(output_data));
 }
 
 TEST_F(PartialCircularBufferTest, WrapTwiceWithSingleWrite) {
   const size_t kInputSize = sizeof(kInputData);
   const size_t kLargeSize = kInputSize * 7;
-  uint8_t large_input[kLargeSize] = {};
-  for (size_t offset = 0; offset < kLargeSize; offset += kInputSize)
-    UNSAFE_TODO(memcpy(large_input + offset, kInputData, kInputSize));
+  std::vector<uint8_t> large_input(kLargeSize);
+  for (size_t offset = 0; offset < kLargeSize; offset += kInputSize) {
+    base::span(large_input).subspan(offset, kInputSize).copy_from(kInputData);
+  }
 
   InitWriteBuffer(false);
-  pcb_write_->Write(large_input, kLargeSize);
+  pcb_write_->Write(large_input.data(), kLargeSize);
   InitReadBuffer();
 
-  uint8_t output_data[sizeof(kOutputRefDataWrap)] = {};
-  EXPECT_EQ(sizeof(output_data),
-            pcb_read_->Read(output_data, sizeof(output_data)));
+  std::array<uint8_t, sizeof(kOutputRefDataWrap)> output_data = {};
+  EXPECT_EQ(sizeof(output_data), pcb_read_->Read(output_data));
 
-  UNSAFE_TODO(EXPECT_EQ(
-      0, memcmp(kOutputRefDataWrap, output_data, sizeof(output_data))));
+  EXPECT_TRUE(std::equal(std::begin(kOutputRefDataWrap),
+                         std::end(kOutputRefDataWrap), output_data.begin()));
 
-  EXPECT_EQ(0u, pcb_read_->Read(output_data, sizeof(output_data)));
+  EXPECT_EQ(0u, pcb_read_->Read(output_data));
 }
 
 }  // namespace webrtc_logging
