diff --git a/components/pwg_encoder/bitmap_image.cc b/components/pwg_encoder/bitmap_image.cc
index 3ff4ec23adebc..d33e71ad4933e 100644
--- a/components/pwg_encoder/bitmap_image.cc
+++ b/components/pwg_encoder/bitmap_image.cc
@@ -4,6 +4,7 @@
 
 #include "components/pwg_encoder/bitmap_image.h"
 
+#include "base/containers/span.h"
 #include "base/check_op.h"
 #include "base/compiler_specific.h"
 
@@ -24,7 +25,7 @@ uint8_t BitmapImage::channels() const {
   return kCurrentlySupportedNumberOfChannels;
 }
 
-const uint8_t* BitmapImage::GetPixel(const gfx::Point& point) const {
+base::span<const uint8_t> BitmapImage::GetPixel(const gfx::Point& point) const {
   DCHECK_LT(point.x(), size_.width());
   DCHECK_LT(point.y(), size_.height());
   return UNSAFE_TODO(data_.get() +
diff --git a/components/pwg_encoder/bitmap_image.h b/components/pwg_encoder/bitmap_image.h
index b2bbff47bd432..7eda429b6ff7b 100644
--- a/components/pwg_encoder/bitmap_image.h
+++ b/components/pwg_encoder/bitmap_image.h
@@ -9,6 +9,7 @@
 
 #include <memory>
 
+#include "base/containers/span.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/size.h"
 
@@ -34,9 +35,9 @@ class BitmapImage {
   Colorspace colorspace() const { return colorspace_; }
 
   const uint8_t* pixel_data() const { return data_.get(); }
-  uint8_t* pixel_data() { return data_.get(); }
+  base::span<uint8_t> pixel_data() { return data_.get(); }
 
-  const uint8_t* GetPixel(const gfx::Point& point) const;
+  base::span<const uint8_t> GetPixel(const gfx::Point& point) const;
 
  private:
   gfx::Size size_;
diff --git a/components/pwg_encoder/pwg_encoder.cc b/components/pwg_encoder/pwg_encoder.cc
index f792fdcd2d82d..8815daec8e6ca 100644
--- a/components/pwg_encoder/pwg_encoder.cc
+++ b/components/pwg_encoder/pwg_encoder.cc
@@ -184,7 +184,7 @@ void EncodeRow(RandomAccessIterator pos,
   }
 }
 
-const uint8_t* GetRow(const BitmapImage& image, int row, bool flipy) {
+base::span<const uint8_t> GetRow(const BitmapImage& image, int row, bool flipy) {
   return image.GetPixel(
       gfx::Point(0, flipy ? image.size().height() - 1 - row : row));
 }
@@ -201,14 +201,14 @@ std::string EncodePageWithColorspace(const BitmapImage& image,
 
   int row_number = 0;
   while (row_number < image.size().height()) {
-    const uint8_t* current_row =
+    base::span<const uint8_t>current_row =
         GetRow(image, row_number++, pwg_header_info.flipy);
     int num_identical_rows = 1;
     // We count how many times the current row is repeated.
     while (num_identical_rows < kPwgMaxPackedRows &&
            row_number < image.size().height() &&
-           !UNSAFE_TODO(memcmp(current_row,
-                               GetRow(image, row_number, pwg_header_info.flipy),
+           !UNSAFE_TODO(memcmp(current_row.data(),
+                               GetRow(image, row_number, pwg_header_info.flipy).data(),
                                row_size))) {
       num_identical_rows++;
       row_number++;
@@ -220,14 +220,14 @@ std::string EncodePageWithColorspace(const BitmapImage& image,
     // of information and comparison of elements is easier. The actual
     // Management of the bytes of the pixel is done by pixel_encoder function
     // on the original array to avoid endian problems.
-    const uint32_t* pos = reinterpret_cast<const uint32_t*>(current_row);
-    const uint32_t* row_end = UNSAFE_TODO(pos + image.size().width());
+    base::span<const uint32_t>pos = reinterpret_cast<const uint32_t*>(current_row);
+    const uint32_t* row_end = UNSAFE_TODO(UNSAFE_TODO(pos.data() + image.size().width()));
     if (!pwg_header_info.flipx) {
       EncodeRow<InputStruct>(pos, row_end, monochrome, &output);
     } else {
       // We reverse the iterators.
       EncodeRow<InputStruct>(std::reverse_iterator<const uint32_t*>(row_end),
-                             std::reverse_iterator<const uint32_t*>(pos),
+                             std::reverse_iterator<const uint32_t*>(pos.data()),
                              monochrome, &output);
     }
   }
diff --git a/components/pwg_encoder/pwg_encoder_unittest.cc b/components/pwg_encoder/pwg_encoder_unittest.cc
index 347de17c55725..2b1a2f7981753 100644
--- a/components/pwg_encoder/pwg_encoder_unittest.cc
+++ b/components/pwg_encoder/pwg_encoder_unittest.cc
@@ -8,6 +8,7 @@
 
 #include <memory>
 
+#include "base/containers/span.h"
 #include "base/compiler_specific.h"
 #include "base/hash/sha1.h"
 #include "base/strings/string_number_conversions.h"
@@ -25,7 +26,7 @@ const int kRasterDPI = 72;
 std::unique_ptr<BitmapImage> MakeSampleBitmap() {
   auto bitmap_image = std::make_unique<BitmapImage>(
       gfx::Size(kRasterWidth, kRasterHeight), BitmapImage::RGBA);
-  uint32_t* bitmap_data =
+  base::span<uint32_t>bitmap_data =
       reinterpret_cast<uint32_t*>(bitmap_image->pixel_data());
   for (int i = 0; i < kRasterWidth * kRasterHeight; i++)
     UNSAFE_TODO(bitmap_data[i]) = 0xFFFFFF;
diff --git a/media/audio/alsa/alsa_input.cc b/media/audio/alsa/alsa_input.cc
index baaddbde76ca5..93917b93786b4 100644
--- a/media/audio/alsa/alsa_input.cc
+++ b/media/audio/alsa/alsa_input.cc
@@ -211,7 +211,9 @@ void AlsaPcmInputStream::ReadAudio() {
                                          params_.frames_per_buffer());
     if (frames_read == params_.frames_per_buffer()) {
       audio_bus_->FromInterleaved<SignedInt16SampleTypeTraits>(
-          reinterpret_cast<int16_t*>(audio_buffer_.get()),
+          UNSAFE_TODO(base::span(
+              reinterpret_cast<int16_t*>(audio_buffer_.get()),
+              static_cast<size_t>(audio_bus_->frames()) * params_.channels())),
           audio_bus_->frames());
 
       // TODO(dalecurtis): This should probably use snd_pcm_htimestamp() so that
diff --git a/media/audio/audio_debug_file_writer_unittest.cc b/media/audio/audio_debug_file_writer_unittest.cc
index a68005f5fd300..8ce63576c51ea 100644
--- a/media/audio/audio_debug_file_writer_unittest.cc
+++ b/media/audio/audio_debug_file_writer_unittest.cc
@@ -231,9 +231,9 @@ class AudioDebugFileWriterTest
           AudioBus::Create(params_.channels(), params_.frames_per_buffer());
 
       bus->FromInterleaved<media::SignedInt16SampleTypeTraits>(
-          source_interleaved_
-              .subspan(i * params_.channels() * params_.frames_per_buffer())
-              .data(),
+          source_interleaved_.subspan(
+              i * params_.channels() * params_.frames_per_buffer(),
+              params_.channels() * params_.frames_per_buffer()),
           params_.frames_per_buffer());
 
       debug_writer_->Write(*bus);
@@ -325,7 +325,9 @@ TEST_P(AudioDebugFileWriterBehavioralTest, ShouldReuseAudioBusesWithPool) {
 
   std::unique_ptr<AudioBus> bus = AudioBus::Create(params_);
   bus->FromInterleaved<media::SignedInt16SampleTypeTraits>(
-      source_interleaved_.data(), params_.frames_per_buffer());
+      source_interleaved_.first(params_.frames_per_buffer() *
+                                params_.channels()),
+      params_.frames_per_buffer());
 
   debug_writer_->Write(*bus);
   task_environment_.RunUntilIdle();
diff --git a/media/audio/audio_debug_recording_helper_unittest.cc b/media/audio/audio_debug_recording_helper_unittest.cc
index 7aeeae3d73f9e..d3e5cb7257a71 100644
--- a/media/audio/audio_debug_recording_helper_unittest.cc
+++ b/media/audio/audio_debug_recording_helper_unittest.cc
@@ -251,7 +251,7 @@ TEST_F(AudioDebugRecordingHelperTest, OnData) {
     source_data[i] = i * step;
   }
   std::unique_ptr<AudioBus> audio_bus = AudioBus::Create(params);
-  audio_bus->FromInterleaved<Float32SampleTypeTraits>(source_data.data(),
+  audio_bus->FromInterleaved<Float32SampleTypeTraits>(source_data,
                                                       number_of_frames);
 
   std::unique_ptr<AudioDebugRecordingHelper> recording_helper =
diff --git a/media/audio/audio_low_latency_input_output_unittest.cc b/media/audio/audio_low_latency_input_output_unittest.cc
index 2768b9e2c33ee..fc1ad1af043f0 100644
--- a/media/audio/audio_low_latency_input_output_unittest.cc
+++ b/media/audio/audio_low_latency_input_output_unittest.cc
@@ -220,7 +220,10 @@ class FullDuplexAudioSinkSource
       // We should only have 16 bits per sample.
       DCHECK_EQ(frame_size_ / channels_, 2);
       dest->FromInterleaved<SignedInt16SampleTypeTraits>(
-          reinterpret_cast<const int16_t*>(source.data()), size / channels_);
+          UNSAFE_TODO(base::span(
+              reinterpret_cast<const int16_t*>(source.data()),
+              static_cast<size_t>(size) / sizeof(int16_t))),
+          size / channels_);
 
       buffer_->Seek(size);
       return size / frame_size_;
diff --git a/media/audio/simple_sources.cc b/media/audio/simple_sources.cc
index d499fe14c840a..cdbb8da271950 100644
--- a/media/audio/simple_sources.cc
+++ b/media/audio/simple_sources.cc
@@ -319,7 +319,7 @@ int BeepingSource::OnMoreData(base::TimeDelta /* delay */,
   }
 
   last_callback_time_ = base::TimeTicks::Now();
-  dest->FromInterleaved<UnsignedInt8SampleTypeTraits>(buffer_.data(),
+  dest->FromInterleaved<UnsignedInt8SampleTypeTraits>(buffer_,
                                                       dest->frames());
   return dest->frames();
 }
diff --git a/media/audio/wav_audio_handler.cc b/media/audio/wav_audio_handler.cc
index 1d71c7f8aa9fc..45ed365f31a95 100644
--- a/media/audio/wav_audio_handler.cc
+++ b/media/audio/wav_audio_handler.cc
@@ -268,15 +268,23 @@ bool WavAudioHandler::CopyTo(AudioBus* bus, size_t* frames_written) {
       switch (bits_per_sample_) {
         case 8:
           bus->FromInterleaved<UnsignedInt8SampleTypeTraits>(
-              reinterpret_cast<const uint8_t*>(source), frames);
+              UNSAFE_TODO(base::span(reinterpret_cast<const uint8_t*>(source),
+                                     static_cast<size_t>(frames) * num_channels_)),
+              frames);
           break;
         case 16:
           bus->FromInterleaved<SignedInt16SampleTypeTraits>(
-              reinterpret_cast<const int16_t*>(source), frames);
+              UNSAFE_TODO(base::span(
+                  reinterpret_cast<const int16_t*>(source),
+                  static_cast<size_t>(frames) * num_channels_)),
+              frames);
           break;
         case 32:
           bus->FromInterleaved<SignedInt32SampleTypeTraits>(
-              reinterpret_cast<const int32_t*>(source), frames);
+              UNSAFE_TODO(base::span(
+                  reinterpret_cast<const int32_t*>(source),
+                  static_cast<size_t>(frames) * num_channels_)),
+              frames);
           break;
         default:
           NOTREACHED()
@@ -288,11 +296,17 @@ bool WavAudioHandler::CopyTo(AudioBus* bus, size_t* frames_written) {
       switch (bits_per_sample_) {
         case 32:
           bus->FromInterleaved<Float32SampleTypeTraitsNoClip>(
-              reinterpret_cast<const float*>(source), frames);
+              UNSAFE_TODO(base::span(
+                  reinterpret_cast<const float*>(source),
+                  static_cast<size_t>(frames) * num_channels_)),
+              frames);
           break;
         case 64:
           bus->FromInterleaved<Float64SampleTypeTraits>(
-              reinterpret_cast<const double*>(source), frames);
+              UNSAFE_TODO(base::span(
+                  reinterpret_cast<const double*>(source),
+                  static_cast<size_t>(frames) * num_channels_)),
+              frames);
           break;
         default:
           NOTREACHED()
diff --git a/media/base/audio_block_fifo.cc b/media/base/audio_block_fifo.cc
index b8a8418b59c19..6b2280437b350 100644
--- a/media/base/audio_block_fifo.cc
+++ b/media/base/audio_block_fifo.cc
@@ -128,16 +128,20 @@ void AudioBlockFifo::PushInternal(base::span<const uint8_t> source,
       switch (bytes_per_sample) {
         case 1:
           current_block->FromInterleavedPartial<UnsignedInt8SampleTypeTraits>(
-              data_for_current_block->data(), write_pos_, push_frames);
+              *data_for_current_block, write_pos_, push_frames);
           break;
         case 2:
           current_block->FromInterleavedPartial<SignedInt16SampleTypeTraits>(
-              reinterpret_cast<const int16_t*>(data_for_current_block->data()),
+              UNSAFE_TODO(base::span(reinterpret_cast<const int16_t*>(
+                                         data_for_current_block->data()),
+                                     push_frames * channels_)),
               write_pos_, push_frames);
           break;
         case 4:
           current_block->FromInterleavedPartial<SignedInt32SampleTypeTraits>(
-              reinterpret_cast<const int32_t*>(data_for_current_block->data()),
+              UNSAFE_TODO(base::span(reinterpret_cast<const int32_t*>(
+                                         data_for_current_block->data()),
+                                     push_frames * channels_)),
               write_pos_, push_frames);
           break;
         default:
diff --git a/media/base/audio_buffer.cc b/media/base/audio_buffer.cc
index 6d4fcbb7e7d51..967c536d1bd01 100644
--- a/media/base/audio_buffer.cc
+++ b/media/base/audio_buffer.cc
@@ -591,20 +591,29 @@ void AudioBuffer::ReadFrames(int frames_to_copy,
 
   if (sample_format_ == kSampleFormatF32) {
     dest->FromInterleavedPartial<Float32SampleTypeTraits>(
-        reinterpret_cast<const float*>(source_data), dest_frame_offset,
-        frames_to_copy);
+        UNSAFE_TODO(base::span(reinterpret_cast<const float*>(source_data),
+                               static_cast<size_t>(frames_to_copy) *
+                                   channel_count_)),
+        dest_frame_offset, frames_to_copy);
   } else if (sample_format_ == kSampleFormatU8) {
     dest->FromInterleavedPartial<UnsignedInt8SampleTypeTraits>(
-        source_data, dest_frame_offset, frames_to_copy);
+        UNSAFE_TODO(base::span(
+            source_data,
+            static_cast<size_t>(frames_to_copy) * channel_count_)),
+        dest_frame_offset, frames_to_copy);
   } else if (sample_format_ == kSampleFormatS16) {
     dest->FromInterleavedPartial<SignedInt16SampleTypeTraits>(
-        reinterpret_cast<const int16_t*>(source_data), dest_frame_offset,
-        frames_to_copy);
+        UNSAFE_TODO(base::span(
+            reinterpret_cast<const int16_t*>(source_data),
+            static_cast<size_t>(frames_to_copy) * channel_count_)),
+        dest_frame_offset, frames_to_copy);
   } else if (sample_format_ == kSampleFormatS24 ||
              sample_format_ == kSampleFormatS32) {
     dest->FromInterleavedPartial<SignedInt32SampleTypeTraits>(
-        reinterpret_cast<const int32_t*>(source_data), dest_frame_offset,
-        frames_to_copy);
+        UNSAFE_TODO(base::span(
+            reinterpret_cast<const int32_t*>(source_data),
+            static_cast<size_t>(frames_to_copy) * channel_count_)),
+        dest_frame_offset, frames_to_copy);
   } else {
     NOTREACHED() << "Unsupported audio sample type: " << sample_format_;
   }
diff --git a/media/base/audio_bus.h b/media/base/audio_bus.h
index 1be4610a00eef..4486a12de650b 100644
--- a/media/base/audio_bus.h
+++ b/media/base/audio_bus.h
@@ -133,7 +133,7 @@ class MEDIA_EXPORT AudioBus {
   // undefined behavior.
   template <class SourceSampleTypeTraits>
   void FromInterleaved(
-      const typename SourceSampleTypeTraits::ValueType* source_buffer,
+      base::span<const typename SourceSampleTypeTraits::ValueType> source,
       int num_frames_to_write);
 
   // Similar to FromInterleaved...(), but overwrites the frames starting at a
@@ -141,7 +141,7 @@ class MEDIA_EXPORT AudioBus {
   // not overwritten.
   template <class SourceSampleTypeTraits>
   void FromInterleavedPartial(
-      const typename SourceSampleTypeTraits::ValueType* source_buffer,
+      base::span<const typename SourceSampleTypeTraits::ValueType> source,
       int write_offset_in_frames,
       int num_frames_to_write);
 
@@ -256,7 +256,7 @@ class MEDIA_EXPORT AudioBus {
 
   template <class SourceSampleTypeTraits>
   static void CopyConvertFromInterleavedSourceToAudioBus(
-      const typename SourceSampleTypeTraits::ValueType* source_buffer,
+      base::span<const typename SourceSampleTypeTraits::ValueType> source,
       int write_offset_in_frames,
       int num_frames_to_write,
       AudioBus* dest);
@@ -307,9 +307,9 @@ class MEDIA_EXPORT AudioBus {
 // Delegates to FromInterleavedPartial()
 template <class SourceSampleTypeTraits>
 void AudioBus::FromInterleaved(
-    const typename SourceSampleTypeTraits::ValueType* source_buffer,
+    base::span<const typename SourceSampleTypeTraits::ValueType> source,
     int num_frames_to_write) {
-  FromInterleavedPartial<SourceSampleTypeTraits>(source_buffer, 0,
+  FromInterleavedPartial<SourceSampleTypeTraits>(source, 0,
                                                  num_frames_to_write);
   // Zero any remaining frames.
   ZeroFramesPartial(num_frames_to_write, frames_ - num_frames_to_write);
@@ -317,12 +317,12 @@ void AudioBus::FromInterleaved(
 
 template <class SourceSampleTypeTraits>
 void AudioBus::FromInterleavedPartial(
-    const typename SourceSampleTypeTraits::ValueType* source_buffer,
+    base::span<const typename SourceSampleTypeTraits::ValueType> source,
     int write_offset_in_frames,
     int num_frames_to_write) {
   CheckOverflow(write_offset_in_frames, num_frames_to_write, frames_);
   CopyConvertFromInterleavedSourceToAudioBus<SourceSampleTypeTraits>(
-      source_buffer, write_offset_in_frames, num_frames_to_write, this);
+      source, write_offset_in_frames, num_frames_to_write, this);
 }
 
 // Delegates to ToInterleavedPartial()
@@ -348,7 +348,7 @@ void AudioBus::ToInterleavedPartial(
 //                 https://crbug.com/619628
 template <class SourceSampleTypeTraits>
 void AudioBus::CopyConvertFromInterleavedSourceToAudioBus(
-    const typename SourceSampleTypeTraits::ValueType* source_buffer,
+    base::span<const typename SourceSampleTypeTraits::ValueType> source,
     int write_offset_in_frames,
     int num_frames_to_write,
     AudioBus* dest) {
@@ -359,7 +359,7 @@ void AudioBus::CopyConvertFromInterleavedSourceToAudioBus(
              read_pos_in_source = ch;
          target_frame_index < write_offset_in_frames + num_frames_to_write;
          ++target_frame_index, read_pos_in_source += channels) {
-      auto source_value = source_buffer[read_pos_in_source];
+      auto source_value = source[read_pos_in_source];
       channel_data[target_frame_index] =
           SourceSampleTypeTraits::ToFloat(source_value);
     }
diff --git a/media/base/audio_bus_unittest.cc b/media/base/audio_bus_unittest.cc
index 500f9e66b62de..a7d1df123c7c9 100644
--- a/media/base/audio_bus_unittest.cc
+++ b/media/base/audio_bus_unittest.cc
@@ -11,6 +11,7 @@
 #include <limits>
 #include <memory>
 
+#include "base/containers/auto_spanification_helper.h"
 #include "base/compiler_specific.h"
 #include "base/containers/span.h"
 #include "base/memory/aligned_memory.h"
@@ -302,13 +303,14 @@ TEST_F(AudioBusTest, WrapMemory) {
   VerifyReadWriteAndAlignment(bus.get());
 
   // Verify the channel vectors lie within the provided memory block.
-  base::span<const float> backing_memory_start = data.as_span();
+  const float* backing_memory_start = data.as_span().data();
   const float* backing_memory_end =
-      backing_memory_start.subspan(total_frame_count).data();
-  EXPECT_GE(bus->channel_span(0).data(), backing_memory_start.data());
-  UNSAFE_TODO(
-      EXPECT_LT(bus->channel_span(bus->channels() - 1).data() + bus->frames(),
-                backing_memory_end));
+      UNSAFE_TODO(backing_memory_start + data.as_span().size());
+  EXPECT_GE(bus->channel_span(0).data(), backing_memory_start);
+  EXPECT_LT(bus->channel_span(bus->channels() - 1).data(), backing_memory_end);
+  EXPECT_LE(UNSAFE_TODO(bus->channel_span(bus->channels() - 1).data() +
+                        bus->frames()),
+            backing_memory_end);
 }
 
 // Simulate a shared memory transfer and verify results.
@@ -412,15 +414,15 @@ static const uint8_t kTestVectorUint8[kTestVectorSize] = {
 static const int16_t kTestVectorInt16[kTestVectorSize] = {
     INT16_MIN,     0, INT16_MAX, INT16_MIN, INT16_MAX / 2,
     INT16_MIN / 2, 0, INT16_MAX, 0,         0};
-static const int32_t kTestVectorInt32[kTestVectorSize] = {
+static const std::array<int32_t, kTestVectorSize> kTestVectorInt32 = {
     INT32_MIN,     0, INT32_MAX, INT32_MIN, INT32_MAX / 2,
     INT32_MIN / 2, 0, INT32_MAX, 0,         0};
-static const float kTestVectorFloat32[kTestVectorSize] = {
+static const std::array<float, kTestVectorSize> kTestVectorFloat32 = {
     -1.0f, 0.0f, 1.0f, -1.0f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f};
 
 // This is based on kTestVectorFloat32, but has some of the values outside of
 // sanity.
-static const float kTestVectorFloat32Invalid[kTestVectorSize] = {
+static const std::array<float, kTestVectorSize> kTestVectorFloat32Invalid = {
     -5.0f,
     0.0f,
     5.0f,
@@ -432,7 +434,7 @@ static const float kTestVectorFloat32Invalid[kTestVectorSize] = {
     std::numeric_limits<float>::signaling_NaN(),
     std::numeric_limits<float>::quiet_NaN()};
 
-static const float kTestVectorFloat32Sanitized[kTestVectorSize] = {
+static const std::array<float, kTestVectorSize> kTestVectorFloat32Sanitized = {
     -1.0f, 0.0f, 1.0f, -1.0f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f};
 
 // Expected results.
@@ -455,8 +457,8 @@ TEST_F(AudioBusTest, FromInterleaved) {
   {
     SCOPED_TRACE("UnsignedInt8SampleTypeTraits");
     bus->Zero();
-    bus->FromInterleaved<UnsignedInt8SampleTypeTraits>(kTestVectorUint8,
-                                                       kTestVectorFrameCount);
+    bus->FromInterleaved<UnsignedInt8SampleTypeTraits>(
+        base::span(kTestVectorUint8), kTestVectorFrameCount);
     // Biased uint8_t calculations have poor precision, so the epsilon here is
     // slightly more permissive than int16_t and int32_t calculations.
     VerifyAreEqualWithEpsilon(bus.get(), expected.get(),
@@ -465,8 +467,8 @@ TEST_F(AudioBusTest, FromInterleaved) {
   {
     SCOPED_TRACE("SignedInt16SampleTypeTraits");
     bus->Zero();
-    bus->FromInterleaved<SignedInt16SampleTypeTraits>(kTestVectorInt16,
-                                                      kTestVectorFrameCount);
+    bus->FromInterleaved<SignedInt16SampleTypeTraits>(
+        base::span(kTestVectorInt16), kTestVectorFrameCount);
     VerifyAreEqualWithEpsilon(
         bus.get(), expected.get(),
         1.0f /
@@ -513,7 +515,8 @@ TEST_F(AudioBusTest, FromInterleavedPartial) {
     SCOPED_TRACE("SignedInt32SampleTypeTraits");
     bus->Zero();
     bus->FromInterleavedPartial<SignedInt32SampleTypeTraits>(
-        UNSAFE_TODO(kTestVectorInt32 + kPartialStart * bus->channels()),
+        base::span(kTestVectorInt32)
+            .subspan(kPartialStart * bus->channels()),
         kPartialStart, kPartialFrames);
     VerifyAreEqual(bus.get(), expected.get());
   }
@@ -532,15 +535,13 @@ TEST_F(AudioBusTest, ToInterleaved) {
     SCOPED_TRACE("UnsignedInt8SampleTypeTraits");
     uint8_t test_array[std::size(kTestVectorUint8)];
     bus->ToInterleaved<UnsignedInt8SampleTypeTraits>(bus->frames(), test_array);
-    UNSAFE_TODO(ASSERT_EQ(
-        0, memcmp(test_array, kTestVectorUint8, sizeof(kTestVectorUint8))));
+    ASSERT_TRUE(base::span(test_array) == base::span(kTestVectorUint8));
   }
   {
     SCOPED_TRACE("SignedInt16SampleTypeTraits");
     int16_t test_array[std::size(kTestVectorInt16)];
     bus->ToInterleaved<SignedInt16SampleTypeTraits>(bus->frames(), test_array);
-    UNSAFE_TODO(ASSERT_EQ(
-        0, memcmp(test_array, kTestVectorInt16, sizeof(kTestVectorInt16))));
+    ASSERT_TRUE(base::span(test_array) == base::span(kTestVectorInt16));
   }
   {
     SCOPED_TRACE("SignedInt32SampleTypeTraits");
@@ -549,24 +550,19 @@ TEST_F(AudioBusTest, ToInterleaved) {
 
     // Some compilers get better precision than others on the half-max test, so
     // let the test pass with an off by one check on the half-max.
-    int32_t alternative_acceptable_result[std::size(kTestVectorInt32)];
-    UNSAFE_TODO(memcpy(alternative_acceptable_result, kTestVectorInt32,
-                       sizeof(kTestVectorInt32)));
+    auto alternative_acceptable_result = kTestVectorInt32;
     ASSERT_EQ(alternative_acceptable_result[4],
               std::numeric_limits<int32_t>::max() / 2);
     alternative_acceptable_result[4]++;
 
-    UNSAFE_TODO(ASSERT_TRUE(
-        memcmp(test_array, kTestVectorInt32, sizeof(kTestVectorInt32)) == 0 ||
-        memcmp(test_array, alternative_acceptable_result,
-               sizeof(alternative_acceptable_result)) == 0));
+    ASSERT_TRUE(base::span(test_array) == kTestVectorInt32 ||
+                base::span(test_array) == alternative_acceptable_result);
   }
   {
     SCOPED_TRACE("Float32SampleTypeTraits");
     float test_array[std::size(kTestVectorFloat32)];
     bus->ToInterleaved<Float32SampleTypeTraits>(bus->frames(), test_array);
-    UNSAFE_TODO(ASSERT_EQ(
-        0, memcmp(test_array, kTestVectorFloat32, sizeof(kTestVectorFloat32))));
+    ASSERT_TRUE(base::span(test_array) == kTestVectorFloat32);
   }
 }
 
@@ -579,19 +575,19 @@ TEST_F(AudioBusTest, ToInterleavedSanitized) {
   ASSERT_EQ(bus->channel_span(0)[0], kTestVectorFloat32Invalid[0]);
   std::array<float, std::size(kTestVectorFloat32Sanitized)> test_array;
   bus->ToInterleaved<Float32SampleTypeTraits>(bus->frames(), test_array.data());
-  for (size_t i = 0; i < std::size(kTestVectorFloat32Sanitized); ++i)
-    UNSAFE_TODO(ASSERT_EQ(kTestVectorFloat32Sanitized[i], test_array[i]));
+  ASSERT_TRUE(test_array == kTestVectorFloat32Sanitized);
 
   // Verify that Float32SampleTypeTraitsNoClip applied no sanity. Note: We don't
   // use memcmp() here since the NaN type may change on x86 platforms in certain
   // circumstances, see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57484
   bus->ToInterleaved<Float32SampleTypeTraitsNoClip>(bus->frames(),
                                                     test_array.data());
-  for (int i = 0; i < kTestVectorSize; ++i) {
-    if (std::isnan(test_array[i]))
-      UNSAFE_TODO(EXPECT_TRUE(std::isnan(kTestVectorFloat32Invalid[i])));
-    else
-      UNSAFE_TODO(EXPECT_FLOAT_EQ(test_array[i], kTestVectorFloat32Invalid[i]));
+  for (size_t i = 0; i < test_array.size(); ++i) {
+    if (std::isnan(test_array[i])) {
+      EXPECT_TRUE(std::isnan(kTestVectorFloat32Invalid[i]));
+    } else {
+      EXPECT_FLOAT_EQ(test_array[i], kTestVectorFloat32Invalid[i]);
+    }
   }
 }
 
@@ -638,14 +634,13 @@ TEST_F(AudioBusTest, ToInterleavedPartial) {
 
   {
     SCOPED_TRACE("Float32SampleTypeTraits");
-    float test_array[std::size(kTestVectorFloat32)];
+    float test_array[std::size(kTestVectorFloat32)] = {};
     expected->ToInterleavedPartial<Float32SampleTypeTraits>(
         kPartialStart, kPartialFrames, test_array);
-    UNSAFE_TODO(ASSERT_EQ(
-        0, memcmp(test_array,
-                  kTestVectorFloat32 + kPartialStart * kTestVectorChannelCount,
-                  kPartialFrames * sizeof(*kTestVectorFloat32) *
-                      kTestVectorChannelCount)));
+    ASSERT_TRUE(base::span(test_array) ==
+                base::span(kTestVectorFloat32)
+                    .subspan(kPartialStart * kTestVectorChannelCount,
+                             kPartialFrames * kTestVectorChannelCount));
   }
 }
 
@@ -681,7 +676,7 @@ TEST_F(AudioBusTest, FromInterleavedZerosOutUntouchedFrames) {
 
   // Exercise
   test_data.bus_under_test->FromInterleaved<Float32SampleTypeTraits>(
-      &test_data.interleaved_dummy_frames[0], test_data.kInterleavedFrameCount);
+      test_data.interleaved_dummy_frames, test_data.kInterleavedFrameCount);
 
   const size_t untouched_frame_count =
       test_data.kFrameCount - test_data.kInterleavedFrameCount;
@@ -704,7 +699,7 @@ TEST_F(AudioBusTest, FromInterleavedPartialDoesNotZeroOutUntouchedFrames) {
 
     // Exercise
     test_data.bus_under_test->FromInterleavedPartial<Float32SampleTypeTraits>(
-        &test_data.interleaved_dummy_frames[0], kWriteOffsetInFrames,
+        test_data.interleaved_dummy_frames, kWriteOffsetInFrames,
         test_data.kInterleavedFrameCount);
 
     // Verification
@@ -727,7 +722,7 @@ TEST_F(AudioBusTest, FromInterleavedPartialDoesNotZeroOutUntouchedFrames) {
 
     // Exercise
     test_data.bus_under_test->FromInterleavedPartial<Float32SampleTypeTraits>(
-        &test_data.interleaved_dummy_frames[0], kWriteOffsetInFrames,
+        test_data.interleaved_dummy_frames, kWriteOffsetInFrames,
         test_data.kInterleavedFrameCount);
 
     // Verification
diff --git a/media/filters/audio_file_reader.cc b/media/filters/audio_file_reader.cc
index 503e088736d70..ae1027522456a 100644
--- a/media/filters/audio_file_reader.cc
+++ b/media/filters/audio_file_reader.cc
@@ -302,7 +302,9 @@ bool AudioFileReader::OnNewFrame(
 
   if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT) {
     audio_bus->FromInterleaved<Float32SampleTypeTraits>(
-        reinterpret_cast<float*>(frame->data[0]), frames_read);
+        UNSAFE_TODO(base::span(reinterpret_cast<float*>(frame->data[0]),
+                               static_cast<size_t>(frames_read) * channels)),
+        frames_read);
   } else if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLTP) {
     for (int ch = 0; ch < audio_bus->channels(); ++ch) {
       audio_bus->channel_span(ch).copy_from_nonoverlapping(UNSAFE_TODO(
@@ -314,15 +316,24 @@ bool AudioFileReader::OnNewFrame(
     switch (bytes_per_sample) {
       case 1:
         audio_bus->FromInterleaved<UnsignedInt8SampleTypeTraits>(
-            reinterpret_cast<const uint8_t*>(frame->data[0]), frames_read);
+            UNSAFE_TODO(base::span(
+                reinterpret_cast<const uint8_t*>(frame->data[0]),
+                static_cast<size_t>(frames_read) * channels)),
+            frames_read);
         break;
       case 2:
         audio_bus->FromInterleaved<SignedInt16SampleTypeTraits>(
-            reinterpret_cast<const int16_t*>(frame->data[0]), frames_read);
+            UNSAFE_TODO(base::span(
+                reinterpret_cast<const int16_t*>(frame->data[0]),
+                static_cast<size_t>(frames_read) * channels)),
+            frames_read);
         break;
       case 4:
         audio_bus->FromInterleaved<SignedInt32SampleTypeTraits>(
-            reinterpret_cast<const int32_t*>(frame->data[0]), frames_read);
+            UNSAFE_TODO(base::span(
+                reinterpret_cast<const int32_t*>(frame->data[0]),
+                static_cast<size_t>(frames_read) * channels)),
+            frames_read);
         break;
       default:
         NOTREACHED() << "Unsupported bytes per sample encountered: "
diff --git a/media/webrtc/audio_processor_test.cc b/media/webrtc/audio_processor_test.cc
index 0963315846654..218b63fd42ff2 100644
--- a/media/webrtc/audio_processor_test.cc
+++ b/media/webrtc/audio_processor_test.cc
@@ -119,7 +119,10 @@ class AudioProcessorTest : public ::testing::Test {
     int num_preferred_channels = -1;
     for (int i = 0; i < kNumberOfPacketsForTest; ++i) {
       data_bus->FromInterleaved<media::SignedInt16SampleTypeTraits>(
-          data_ptr, data_bus->frames());
+          UNSAFE_TODO(base::span(
+              data_ptr,
+              static_cast<size_t>(data_bus->frames()) * data_bus->channels())),
+          data_bus->frames());
 
       // 1. Provide playout audio, if echo cancellation is enabled.
       const bool is_aec_enabled =
