diff --git a/third_party/blink/renderer/modules/webaudio/delay_handler.cc b/third_party/blink/renderer/modules/webaudio/delay_handler.cc
index 3a2393a..6be84f1 100644
--- a/third_party/blink/renderer/modules/webaudio/delay_handler.cc
+++ b/third_party/blink/renderer/modules/webaudio/delay_handler.cc
@@ -73,16 +73,16 @@
           CHECK(delay_time_->IsAudioRate());
           delay_time_->CalculateSampleAccurateValues(
               kernels_[i]->DelayTimes().first(frames_to_process));
-          kernels_[i]->ProcessARate(source_bus->Channel(i)->Data(),
-                                    destination_bus->Channel(i)->MutableData(),
+          kernels_[i]->ProcessARate(source_bus->Channel(i)->Span(),
+                                    destination_bus->Channel(i)->MutableSpan(),
                                     frames_to_process);
         }
       } else {
         for (unsigned i = 0; i < kernels_.size(); ++i) {
           CHECK(!delay_time_->IsAudioRate());
           kernels_[i]->SetDelayTime(delay_time_->FinalValue());
-          kernels_[i]->ProcessKRate(source_bus->Channel(i)->Data(),
-                                    destination_bus->Channel(i)->MutableData(),
+          kernels_[i]->ProcessKRate(source_bus->Channel(i)->Span(),
+                                    destination_bus->Channel(i)->MutableSpan(),
                                     frames_to_process);
         }
       }
diff --git a/third_party/blink/renderer/platform/audio/cpu/arm/delay_neon.cc b/third_party/blink/renderer/platform/audio/cpu/arm/delay_neon.cc
index 8d95504..7239918 100644
--- a/third_party/blink/renderer/platform/audio/cpu/arm/delay_neon.cc
+++ b/third_party/blink/renderer/platform/audio/cpu/arm/delay_neon.cc
@@ -5,6 +5,7 @@
 #include <arm_neon.h>
 
 #include <algorithm>
+#include <array>
 
 #include "base/compiler_specific.h"
 #include "build/build_config.h"
@@ -51,16 +52,14 @@
                        reinterpret_cast<uint32x4_t>(v_buffer_length), cmp)));
 }
 
-std::tuple<unsigned, int> Delay::ProcessARateVector(
-    float* destination,
-    uint32_t frames_to_process) const {
-  const int buffer_length = buffer_.size();
-  const float* buffer = buffer_.Data();
+std::tuple<size_t, size_t> Delay::ProcessARateVector(
+    base::span<float> destination,
+    size_t frames_to_process) const {
+  const size_t buffer_length = buffer_.size();
 
   const float sample_rate = sample_rate_;
-  const float* delay_times = delay_times_.Data();
 
-  int w_index = write_index_;
+  size_t w_index = write_index_;
 
   const float32x4_t v_sample_rate = vdupq_n_f32(sample_rate);
   const float32x4_t v_all_zeros = vdupq_n_f32(0);
@@ -74,25 +73,26 @@
   const int32x4_t v_incr = vdupq_n_s32(4);
 
   // Temp arrays for storing the samples needed for interpolation
-  float sample1[4] __attribute((aligned(16)));
-  float sample2[4] __attribute((aligned(16)));
+  std::array<float, 4> sample1 __attribute((aligned(16)));
+  std::array<float, 4> sample2 __attribute((aligned(16)));
 
   // Temp array for holding the indices so we can access them
   // individually.
-  int read_index1[4] __attribute((aligned(16)));
-  int read_index2[4] __attribute((aligned(16)));
+  std::array<int, 4> read_index1 __attribute((aligned(16)));
+  std::array<int, 4> read_index2 __attribute((aligned(16)));
 
   // Initialize the write index vector, and  wrap the values if needed.
-  int32x4_t v_write_index = {w_index + 0, w_index + 1, w_index + 2,
-                             w_index + 3};
+  int32x4_t v_write_index = {
+      static_cast<int32_t>(w_index + 0), static_cast<int32_t>(w_index + 1),
+      static_cast<int32_t>(w_index + 2), static_cast<int32_t>(w_index + 3)};
   v_write_index = WrapIndexVector(v_write_index, v_buffer_length_int);
 
   int number_of_loops = frames_to_process / 4;
-  int k = 0;
+  size_t k = 0;
 
   for (int n = 0; n < number_of_loops; ++n, k += 4) {
-    const float32x4_t v_delay_time =
-        vmaxq_f32(UNSAFE_TODO(vld1q_f32(delay_times + k)), v_all_zeros);
+    const float32x4_t v_delay_time = vmaxq_f32(
+        vld1q_f32(delay_times_.as_span().subspan(k, 4u).data()), v_all_zeros);
     const float32x4_t v_desired_delay_frames =
         vmulq_f32(v_delay_time, v_sample_rate);
 
@@ -115,16 +115,16 @@
 
     // Save indices so we can access the components individually for
     // getting the aamples from the buffer.
-    vst1q_s32(read_index1, v_read_index1);
-    vst1q_s32(read_index2, v_read_index2);
+    vst1q_s32(read_index1.data(), v_read_index1);
+    vst1q_s32(read_index2.data(), v_read_index2);
 
     for (int m = 0; m < 4; ++m) {
-      UNSAFE_TODO(sample1[m]) = UNSAFE_TODO(buffer[read_index1[m])];
-      UNSAFE_TODO(sample2[m]) = UNSAFE_TODO(buffer[read_index2[m])];
+      sample1[m] = buffer_[read_index1[m]];
+      sample2[m] = buffer_[read_index2[m]];
     }
 
-    const float32x4_t v_sample1 = vld1q_f32(sample1);
-    const float32x4_t v_sample2 = vld1q_f32(sample2);
+    const float32x4_t v_sample1 = vld1q_f32(sample1.data());
+    const float32x4_t v_sample2 = vld1q_f32(sample2.data());
 
     v_write_index = vaddq_s32(v_write_index, v_incr);
     v_write_index = WrapIndexVector(v_write_index, v_buffer_length_int);
@@ -133,7 +133,7 @@
     const float32x4_t sample = vaddq_f32(
         v_sample1,
         vmulq_f32(interpolation_factor, vsubq_f32(v_sample2, v_sample1)));
-    UNSAFE_TODO(vst1q_f32(destination + k, sample));
+    vst1q_f32(destination.subspan(k, 4u).data(), sample);
   }
 
   // Update |w_index| based on how many frames we processed here, wrapping
@@ -146,8 +146,8 @@
   return std::make_tuple(k, w_index);
 }
 
-void Delay::HandleNaN(float* delay_times,
-                      uint32_t frames_to_process,
+void Delay::HandleNaN(base::span<float> delay_times,
+                      size_t frames_to_process,
                       float max_time) {
   unsigned k = 0;
   int number_of_loops = frames_to_process / 4;
@@ -156,7 +156,7 @@
 
   // This is approximately 4 times faster than the scalar version.
   for (int loop = 0; loop < number_of_loops; ++loop, k += 4) {
-    float32x4_t x = UNSAFE_TODO(vld1q_f32(delay_times + k));
+    float32x4_t x = vld1q_f32(delay_times.subspan(k, 4u).data());
     // x == x only fails when x is NaN.  Then cmp is set to 0. Otherwise
     // 0xffffffff
     uint32x4_t cmp = vceqq_f32(x, x);
@@ -180,14 +180,14 @@
     xint = vorrq_u32(xint, cmp);
 
     // Finally, save the float result.
-    UNSAFE_TODO(
-        vst1q_f32(delay_times + k, reinterpret_cast<float32x4_t>(xint)));
+    vst1q_f32(delay_times.subspan(k, 4u).data(),
+              reinterpret_cast<float32x4_t>(xint));
   }
 
   // Handle any frames not done in the loop above.
   for (; k < frames_to_process; ++k) {
-    if (std::isnan(UNSAFE_TODO(delay_times[k]))) {
-      UNSAFE_TODO(delay_times[k]) = max_time;
+    if (std::isnan(delay_times[k])) {
+      delay_times[k] = max_time;
     }
   }
 }
diff --git a/third_party/blink/renderer/platform/audio/cpu/x86/delay_sse2.cc b/third_party/blink/renderer/platform/audio/cpu/x86/delay_sse2.cc
index ed7fb615..436dc31 100644
--- a/third_party/blink/renderer/platform/audio/cpu/x86/delay_sse2.cc
+++ b/third_party/blink/renderer/platform/audio/cpu/x86/delay_sse2.cc
@@ -52,15 +52,13 @@
   return _mm_sub_ps(v_position, _mm_and_ps(v_buffer_length, cmp));
 }
 
-std::tuple<unsigned, int> Delay::ProcessARateVector(
-    float* destination,
-    uint32_t frames_to_process) const {
-  const int buffer_length = buffer_.size();
-  const float* buffer = buffer_.Data();
+std::tuple<size_t, size_t> Delay::ProcessARateVector(
+    base::span<float> destination,
+    size_t frames_to_process) const {
+  const size_t buffer_length = buffer_.size();
 
   const float sample_rate = sample_rate_;
-  const float* delay_times = delay_times_.Data();
-  int w_index = write_index_;
+  size_t w_index = write_index_;
 
   const __m128 v_sample_rate = _mm_set1_ps(sample_rate);
   const __m128 v_all_zeros = _mm_setzero_ps();
@@ -82,14 +80,15 @@
       _mm_set_epi32(w_index + 3, w_index + 2, w_index + 1, w_index + 0);
   v_write_index = WrapIndexVector(v_write_index, v_buffer_length_int);
 
-  const int number_of_loops = frames_to_process / 4;
-  int k = 0;
+  const size_t number_of_loops = frames_to_process / 4;
+  size_t k = 0;
 
-  for (int n = 0; n < number_of_loops; ++n, k += 4) {
+  for (size_t n = 0; n < number_of_loops; ++n, k += 4) {
     // It's possible that `delay_time` contains negative values. Make sure
     // they are greater than zero.
     const __m128 v_delay_time =
-        _mm_max_ps(_mm_loadu_ps(UNSAFE_TODO(delay_times + k)), v_all_zeros);
+        _mm_max_ps(_mm_loadu_ps(delay_times_.as_span().subspan(k, 4u).data()),
+                   v_all_zeros);
     const __m128 v_desired_delay_frames =
         _mm_mul_ps(v_delay_time, v_sample_rate);
 
@@ -116,8 +115,8 @@
         reinterpret_cast<const uint32_t*>(&v_read_index2);
 
     for (int m = 0; m < 4; ++m) {
-      sample1[m] = UNSAFE_TODO(buffer[read_index1[m]]);
-      sample2[m] = UNSAFE_TODO(buffer[read_index2[m]]);
+      sample1[m] = buffer_[UNSAFE_TODO(read_index1[m])];
+      sample2[m] = buffer_[UNSAFE_TODO(read_index2[m])];
     }
 
     const __m128 v_sample1 = _mm_load_ps(sample1.data());
@@ -129,7 +128,7 @@
     const __m128 sample = _mm_add_ps(
         v_sample1,
         _mm_mul_ps(interpolation_factor, _mm_sub_ps(v_sample2, v_sample1)));
-    _mm_store_ps(UNSAFE_TODO(destination + k), sample);
+    _mm_store_ps(destination.subspan(k, 4u).data(), sample);
   }
 
   // Update |w_index|_ based on how many frames we processed here, wrapping
@@ -142,8 +141,8 @@
   return std::make_tuple(k, w_index);
 }
 
-void Delay::HandleNaN(float* delay_times,
-                      uint32_t frames_to_process,
+void Delay::HandleNaN(base::span<float> delay_times,
+                      size_t frames_to_process,
                       float max_time) {
   unsigned k = 0;
   const unsigned number_of_loops = frames_to_process / 4;
@@ -152,7 +151,7 @@
 
   // This is approximately 4 times faster than the scalar version.
   for (unsigned loop = 0; loop < number_of_loops; ++loop, k += 4) {
-    __m128 x = _mm_loadu_ps(UNSAFE_TODO(delay_times + k));
+    __m128 x = _mm_loadu_ps(delay_times.subspan(k, 4u).data());
     // 0xffffffff if x is NaN. Otherwise 0
     __m128 cmp = _mm_cmpunord_ps(x, x);
 
@@ -166,13 +165,13 @@
     // Merge i (bitwise or) x and cmp.  This makes x = max_time if x was NaN and
     // preserves x if not.
     x = _mm_or_ps(x, cmp);
-    _mm_storeu_ps(UNSAFE_TODO(delay_times + k), x);
+    _mm_storeu_ps(delay_times.subspan(k, 4u).data(), x);
   }
 
   // Handle any frames not done in the loop above.
   for (; k < frames_to_process; ++k) {
-    if (std::isnan(UNSAFE_TODO(delay_times[k]))) {
-      UNSAFE_TODO(delay_times[k]) = max_time;
+    if (std::isnan(delay_times[k])) {
+      delay_times[k] = max_time;
     }
   }
 }
diff --git a/third_party/blink/renderer/platform/audio/delay.cc b/third_party/blink/renderer/platform/audio/delay.cc
index 097005e..ea4159a 100644
--- a/third_party/blink/renderer/platform/audio/delay.cc
+++ b/third_party/blink/renderer/platform/audio/delay.cc
@@ -38,31 +38,29 @@
 
 namespace {
 
-void CopyToCircularBuffer(float* buffer,
-                          int write_index,
-                          int buffer_length,
-                          const float* source,
-                          uint32_t frames_to_process) {
+void CopyToCircularBuffer(base::span<float> buffer,
+                          size_t write_index,
+                          base::span<const float> source,
+                          size_t frames_to_process) {
   // The algorithm below depends on this being true because we don't expect to
   // have to fill the entire buffer more than once.
-  DCHECK_GE(static_cast<uint32_t>(buffer_length), frames_to_process);
+  DCHECK_GE(buffer.size(), frames_to_process);
+  DCHECK_GE(buffer.size(), write_index);
 
   // Copy `frames_to_process` values from `source` to the circular buffer that
-  // starts at `buffer` of length `buffer_length`.  The copy starts at index
+  // starts at `buffer` of length `buffer.size()`.  The copy starts at index
   // `write_index` into the buffer.
-  float* write_pointer = &UNSAFE_TODO(buffer[write_index]);
-  int remainder = buffer_length - write_index;
+  const size_t remainder = buffer.size() - write_index;
 
-  // Copy the sames over, carefully handling the case where we need to wrap
-  // around to the beginning of the buffer.
-  UNSAFE_TODO(
-      memcpy(write_pointer, source,
-             sizeof(*write_pointer) *
-                 std::min(static_cast<int>(frames_to_process), remainder)));
-  UNSAFE_TODO(
-      memcpy(buffer, source + remainder,
-             sizeof(*write_pointer) *
-                 std::max(0, static_cast<int>(frames_to_process) - remainder)));
+  // Carefully handle the case where we need to wrap around to the beginning of
+  // the buffer.
+  const size_t first_size = std::min(frames_to_process, remainder);
+  buffer.subspan(write_index, first_size).copy_from(source.first(first_size));
+
+  if (frames_to_process > remainder) {
+    const size_t second_size = frames_to_process - remainder;
+    buffer.first(second_size).copy_from(source.subspan(remainder, second_size));
+  }
 }
 
 }  // namespace
@@ -103,7 +101,7 @@
 
 #if !(defined(ARCH_CPU_X86_FAMILY) || defined(CPU_ARM_NEON))
 // Default scalar versions if simd/neon are not available.
-std::tuple<unsigned, int> Delay::ProcessARateVector(
+std::tuple<size_t, size_t> Delay::ProcessARateVector(
     float* destination,
     uint32_t frames_to_process) const {
   // We don't have a vectorized version, so just do nothing and return the 0 to
@@ -111,10 +109,10 @@
   return std::make_tuple(0, write_index_);
 }
 
-void Delay::HandleNaN(float* delay_times,
-                      uint32_t frames_to_process,
+void Delay::HandleNaN(base::span<float> delay_times,
+                      size_t frames_to_process,
                       float max_time) {
-  for (unsigned k = 0; k < frames_to_process; ++k) {
+  for (size_t k = 0; k < frames_to_process; ++k) {
     if (std::isnan(delay_times[k])) {
       delay_times[k] = max_time;
     }
@@ -122,78 +120,60 @@
 }
 #endif
 
-int Delay::ProcessARateScalar(unsigned start,
-                              int w_index,
-                              float* destination,
-                              uint32_t frames_to_process) const {
-  const int buffer_length = buffer_.size();
-  const float* buffer = buffer_.Data();
+size_t Delay::ProcessARateScalar(size_t start,
+                                 size_t w_index,
+                                 base::span<float> destination,
+                                 size_t frames_to_process) const {
+  const size_t buffer_length = buffer_.size();
 
-  DCHECK(buffer_length);
-  DCHECK(destination);
-  DCHECK_GE(write_index_, 0);
   DCHECK_LT(write_index_, buffer_length);
 
-  float sample_rate = sample_rate_;
-  const float* delay_times = delay_times_.Data();
-
   for (unsigned i = start; i < frames_to_process; ++i) {
-    double delay_time = std::fmax(UNSAFE_TODO(delay_times[i]), 0);
-    double desired_delay_frames = delay_time * sample_rate;
+    double delay_time = std::fmax(delay_times_[i], 0);
+    double desired_delay_frames = delay_time * sample_rate_;
 
     double read_position = w_index + buffer_length - desired_delay_frames;
     if (read_position >= buffer_length) {
       read_position -= buffer_length;
     }
+    DCHECK_GE(read_position, 0);
 
     // Linearly interpolate in-between delay times.
-    int read_index1 = static_cast<int>(read_position);
-    DCHECK_GE(read_index1, 0);
+    size_t read_index1 = static_cast<size_t>(read_position);
     DCHECK_LT(read_index1, buffer_length);
-    int read_index2 = read_index1 + 1;
+    size_t read_index2 = read_index1 + 1;
     if (read_index2 >= buffer_length) {
       read_index2 -= buffer_length;
     }
-    DCHECK_GE(read_index2, 0);
     DCHECK_LT(read_index2, buffer_length);
 
     float interpolation_factor = read_position - read_index1;
 
-    float sample1 = UNSAFE_TODO(buffer[read_index1]);
-    float sample2 = UNSAFE_TODO(buffer[read_index2]);
+    float sample1 = buffer_[read_index1];
+    float sample2 = buffer_[read_index2];
 
... (file diff truncated)