diff --git a/media/audio/android/aaudio_stream_wrapper.cc b/media/audio/android/aaudio_stream_wrapper.cc
index 2d3ae4bb..bcf62f4 100644
--- a/media/audio/android/aaudio_stream_wrapper.cc
+++ b/media/audio/android/aaudio_stream_wrapper.cc
@@ -13,6 +13,7 @@
 #include "base/android/device_info.h"
 #include "base/feature_list.h"
 #include "base/functional/callback_helpers.h"
+#include "base/functional/bind.h"
 #include "base/logging.h"
 #include "base/memory/aligned_memory.h"
 #include "base/memory/raw_ptr.h"
@@ -34,6 +35,11 @@
 
 namespace {
 
+constexpr base::TimeDelta kCloseDelay = base::Seconds(1);
+// Delay destruction of the helper slightly longer than the close delay, to
+// ensure callbacks have stopped after close.
+constexpr base::TimeDelta kDestructionDelay = kCloseDelay + base::Milliseconds(250);
+
 constexpr char kAAudioBufferSizeInFramesMetricsPrefix[] =
     "Media.Audio.Android.AAudioBufferSizeInFrames.";
 constexpr char kAAudioFramesPerDataCallbackMetricsPrefix[] =
@@ -181,8 +187,19 @@
 
   ~AAudioDestructionHelper() {
     CHECK(is_closing_);
-    if (aaudio_stream_) {
-      AAudioStream_close(aaudio_stream_);
+    // Fallback if the delayed close task was dropped during shutdown.
+    CloseDeferredStream();
+  }
+
+  void CloseDeferredStream() {
+    raw_ptr<AAudioStream> stream_to_close = nullptr;
+    {
+      base::AutoLock al(lock_);
+      stream_to_close = aaudio_stream_;
+      aaudio_stream_ = nullptr;
+    }
+    if (stream_to_close) {
+      AAudioStream_close(stream_to_close);
     }
   }
 
@@ -425,9 +442,10 @@
 
   CHECK(!aaudio_stream_);
 
-  // On Android S+, |destruction_helper_| can be destroyed as part of the
+  // On Android S+, `destruction_helper_` can be destroyed as part of the
   // normal class teardown.
   if (__builtin_available(android 31, *)) {
+    destruction_helper_->CloseDeferredStream();
     return;
   }
 
@@ -435,11 +453,26 @@
   // after calling AAudioStream_close(). The code below is a mitigation to
   // work around this issue. See crbug.com/1183255.
 
-  // Keep |destruction_helper_| alive longer than |this|, so the |user_data|
+  // Keep `destruction_helper_` alive longer than `this`, so the `user_data`
   // bound to the callback stays valid, until the callbacks stop.
+  //
+  // We post two tasks:
+  // 1. A task to close the stream (at T+1s).
+  // 2. A task to destroy the helper (at T+1.25s).
+  //
+  // The helper raw pointer is safe to use in the first task because the helper
+  // is guaranteed to be kept alive by the second task which has a longer delay
+  // on the same sequence.
+  auto* helper_raw = destruction_helper_.get();
+  base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
+      FROM_HERE,
+      base::BindOnce(&AAudioDestructionHelper::CloseDeferredStream,
+                     base::Unretained(helper_raw)),
+      kCloseDelay);
+
   base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
       FROM_HERE, base::DoNothingWithBoundArgs(std::move(destruction_helper_)),
-      base::Seconds(1));
+      kDestructionDelay);
 }
 
 bool AAudioStreamWrapper::Open() {
diff --git a/media/audio/android/aaudio_stream_wrapper_unittest.cc b/media/audio/android/aaudio_stream_wrapper_unittest.cc
new file mode 100644
index 0000000..3c46416a
--- /dev/null
+++ b/media/audio/android/aaudio_stream_wrapper_unittest.cc
@@ -0,0 +1,86 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "media/audio/android/aaudio_stream_wrapper.h"
+
+#include <aaudio/AAudio.h>
+
+#include <memory>
+
+#include "base/android/android_info.h"
+#include "base/test/task_environment.h"
+#include "media/base/audio_parameters.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+namespace {
+
+class MockDataCallback : public AAudioStreamWrapper::DataCallback {
+ public:
+  MockDataCallback() = default;
+  ~MockDataCallback() override = default;
+  bool OnAudioDataRequested(base::span<float> audio_data) override {
+    return true;
+  }
+  void OnError() override {}
+  void OnDeviceChange() override {}
+};
+
+}  // namespace
+
+class AAudioStreamWrapperTest : public testing::Test {
+ protected:
+  base::test::SingleThreadTaskEnvironment task_environment_{
+      base::test::TaskEnvironment::TimeSource::MOCK_TIME};
+  MockDataCallback callback_;
+};
+
+TEST_F(AAudioStreamWrapperTest, DeferredHelperOutlivesStreamClose) {
+  AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                         ChannelLayoutConfig::Stereo(), 48000, 480);
+
+  auto wrapper = std::make_unique<AAudioStreamWrapper>(
+      &callback_, AAudioStreamWrapper::StreamType::kOutput, params,
+      android::AudioDevice::Default(), AAUDIO_USAGE_MEDIA);
+
+  // Destroy the wrapper. This should trigger the deferred teardown on API <= 30.
+  wrapper.reset();
+
+  auto sdk_int = base::android::android_info::sdk_int();
+  if (sdk_int < 31) {
+    // We expect two tasks to be posted:
+    // 1. Close task at T+1s.
+    // 2. Free task at T+1.25s.
+    EXPECT_EQ(task_environment_.GetPendingMainThreadTaskCount(), 2u);
+
+    // Fast forward to T+1s (but not 1.25s).
+    task_environment_.FastForwardBy(base::Seconds(1));
+
+    // The close task should have run, but the free task should still be pending.
+    EXPECT_EQ(task_environment_.GetPendingMainThreadTaskCount(), 1u);
+
+    // Fast forward the rest.
+    task_environment_.FastForwardBy(base::Milliseconds(250));
+    EXPECT_EQ(task_environment_.GetPendingMainThreadTaskCount(), 0u);
+  } else {
+    // On API >= 31, destruction should be synchronous, no tasks posted.
+    EXPECT_EQ(task_environment_.GetPendingMainThreadTaskCount(), 0u);
+  }
+}
+
+TEST_F(AAudioStreamWrapperTest, DestroyWithPendingDeferredTasks) {
+  // This test verifies that if the TaskEnvironment is destroyed (or sequence shut down)
+  // while tasks are pending, it doesn't crash.
+  AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                         ChannelLayoutConfig::Stereo(), 48000, 480);
+  auto wrapper = std::make_unique<AAudioStreamWrapper>(
+      &callback_, AAudioStreamWrapper::StreamType::kOutput, params,
+      android::AudioDevice::Default(), AAUDIO_USAGE_MEDIA);
+  wrapper.reset();
+  // We leave the tasks pending. The fixture's `task_environment_` will be
+  // destroyed on teardown, verifying that destroying pending tasks doesn't crash.
+}
+
+}  // namespace media
diff --git a/media/audio/BUILD.gn b/media/audio/BUILD.gn
index 1c0c28de..42f2bcc 100644
--- a/media/audio/BUILD.gn
+++ b/media/audio/BUILD.gn
@@ -482,6 +482,7 @@
 
   if (is_android) {
     sources += [
+      "android/aaudio_stream_wrapper_unittest.cc",
       "android/audio_android_unittest.cc",
       "android/audio_device_id_unittest.cc",
       "android/audio_device_type_unittest.cc",

diff --git a/media/audio/android/aaudio_stream_wrapper_unittest.cc b/media/audio/android/aaudio_stream_wrapper_unittest.cc
new file mode 100644
index 0000000..3c46416a
--- /dev/null
+++ b/media/audio/android/aaudio_stream_wrapper_unittest.cc
@@ -0,0 +1,86 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "media/audio/android/aaudio_stream_wrapper.h"
+
+#include <aaudio/AAudio.h>
+
+#include <memory>
+
+#include "base/android/android_info.h"
+#include "base/test/task_environment.h"
+#include "media/base/audio_parameters.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+namespace {
+
+class MockDataCallback : public AAudioStreamWrapper::DataCallback {
+ public:
+  MockDataCallback() = default;
+  ~MockDataCallback() override = default;
+  bool OnAudioDataRequested(base::span<float> audio_data) override {
+    return true;
+  }
+  void OnError() override {}
+  void OnDeviceChange() override {}
+};
+
+}  // namespace
+
+class AAudioStreamWrapperTest : public testing::Test {
+ protected:
+  base::test::SingleThreadTaskEnvironment task_environment_{
+      base::test::TaskEnvironment::TimeSource::MOCK_TIME};
+  MockDataCallback callback_;
+};
+
+TEST_F(AAudioStreamWrapperTest, DeferredHelperOutlivesStreamClose) {
+  AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                         ChannelLayoutConfig::Stereo(), 48000, 480);
+
+  auto wrapper = std::make_unique<AAudioStreamWrapper>(
+      &callback_, AAudioStreamWrapper::StreamType::kOutput, params,
+      android::AudioDevice::Default(), AAUDIO_USAGE_MEDIA);
+
+  // Destroy the wrapper. This should trigger the deferred teardown on API <= 30.
+  wrapper.reset();
+
+  auto sdk_int = base::android::android_info::sdk_int();
+  if (sdk_int < 31) {
+    // We expect two tasks to be posted:
+    // 1. Close task at T+1s.
+    // 2. Free task at T+1.25s.
+    EXPECT_EQ(task_environment_.GetPendingMainThreadTaskCount(), 2u);
+
+    // Fast forward to T+1s (but not 1.25s).
+    task_environment_.FastForwardBy(base::Seconds(1));
+
+    // The close task should have run, but the free task should still be pending.
+    EXPECT_EQ(task_environment_.GetPendingMainThreadTaskCount(), 1u);
+
+    // Fast forward the rest.
+    task_environment_.FastForwardBy(base::Milliseconds(250));
+    EXPECT_EQ(task_environment_.GetPendingMainThreadTaskCount(), 0u);
+  } else {
+    // On API >= 31, destruction should be synchronous, no tasks posted.
+    EXPECT_EQ(task_environment_.GetPendingMainThreadTaskCount(), 0u);
+  }
+}
+
+TEST_F(AAudioStreamWrapperTest, DestroyWithPendingDeferredTasks) {
+  // This test verifies that if the TaskEnvironment is destroyed (or sequence shut down)
+  // while tasks are pending, it doesn't crash.
+  AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                         ChannelLayoutConfig::Stereo(), 48000, 480);
+  auto wrapper = std::make_unique<AAudioStreamWrapper>(
+      &callback_, AAudioStreamWrapper::StreamType::kOutput, params,
+      android::AudioDevice::Default(), AAUDIO_USAGE_MEDIA);
+  wrapper.reset();
+  // We leave the tasks pending. The fixture's `task_environment_` will be
+  // destroyed on teardown, verifying that destroying pending tasks doesn't crash.
+}
+
+}  // namespace media