Migrate media/ to start-from-one ref counting

Add REQUIRE_FOR_REFCOUNTED_TYPE to all subclases of
base::RefCountedThreadSafe in media/ and use base::MakeRefCounted
instead of `new` for object creation where needed.

In this CL, the remaining classes in media/base/ and media/audio/ are
migrated. The rest of the changes will be handled in a follow-up CL.

See
https://source.chromium.org/chromium/chromium/src/+/main:base/memory/ref_counted.h;l=309;drc=082e8ce5d3bff64458678297dffa15ea5cfc8611
for the motivations to use start-from-one ref count.

Bug: 40608481
Change-Id: I528188f3314d3eaadfdd219fa65f75bff63a11a1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6198498
Reviewed-by: Colin Blundell <blundell@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Kenneth MacKay <kmackay@chromium.org>
Reviewed-by: Pilar Molina Lopez <pmolinalopez@chromium.org>
Commit-Queue: Henrique Ferreiro <hferreiro@igalia.com>
Reviewed-by: Wez <wez@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1418202}

chromecast/media/cma/backend/android/audio_decoder_android.cc

@@ -11,6 +11,7 @@
 
 #include "base/functional/callback_helpers.h"
 #include "base/logging.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/trace_event/trace_event.h"
 #include "chromecast/base/task_runner_impl.h"
 #include "chromecast/media/api/decoder_buffer_base.h"
@@ -82,7 +83,7 @@ AudioDecoderAndroid::AudioDecoderAndroid(MediaPipelineBackendAndroid* backend,
       current_pts_(kInvalidTimestamp),
       pending_output_frames_(kNoPendingOutput),
       volume_multiplier_(1.0f),
-      pool_(new ::media::AudioBufferMemoryPool()),
+      pool_(base::MakeRefCounted<::media::AudioBufferMemoryPool>()),
       weak_factory_(this) {
   LOG(INFO) << __func__ << ":";
   TRACE_FUNCTION_ENTRY0();
@@ -615,8 +616,9 @@ void AudioDecoderAndroid::PushRateShifted() {
   DCHECK_GE(possible_output_frames, rate_info->output_frames);
 
   int channel_data_size = out_frames * sizeof(float);
-  scoped_refptr<DecoderBufferBase> output_buffer(new DecoderBufferAdapter(
-      new ::media::DecoderBuffer(channel_data_size * config_.channel_number)));
+  scoped_refptr<DecoderBufferBase> output_buffer(
+      new DecoderBufferAdapter(base::MakeRefCounted<::media::DecoderBuffer>(
+          channel_data_size * config_.channel_number)));
   for (int c = 0; c < config_.channel_number; ++c) {
     memcpy(output_buffer->writable_data() + c * channel_data_size,
            rate_shifter_output_->channel(c), channel_data_size);

chromecast/media/cma/backend/audio_decoder_for_mixer.cc

@@ -107,7 +107,7 @@ AudioDecoderForMixer::AudioDecoderForMixer(
       task_runner_(backend->GetTaskRunner()),
       buffer_pool_frames_(kInitialFillSizeFrames),
       pending_output_frames_(kNoPendingOutput),
-      pool_(new ::media::AudioBufferMemoryPool()),
+      pool_(base::MakeRefCounted<::media::AudioBufferMemoryPool>()),
       weak_factory_(this) {
   TRACE_FUNCTION_ENTRY0();
   DCHECK(backend_);

chromecast/media/cma/backend/audio_video_pipeline_device_unittest.cc

@@ -14,7 +14,7 @@
 #include "base/functional/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/task/single_thread_task_runner.h"
@@ -388,9 +388,9 @@ void BufferFeeder::FeedBuffer() {
 
 void BufferFeeder::FeedPcm() {
   const int num_frames = 512;
-  scoped_refptr<::media::DecoderBuffer> silence_buffer(
-      new ::media::DecoderBuffer(num_frames * audio_config_.channel_number *
-                                 audio_config_.bytes_per_channel));
+  auto silence_buffer = base::MakeRefCounted<::media::DecoderBuffer>(
+      num_frames * audio_config_.channel_number *
+      audio_config_.bytes_per_channel);
   memset(silence_buffer->writable_data(), 0, silence_buffer->size());
   pending_buffer_ = new media::DecoderBufferAdapter(silence_buffer);
   pending_buffer_->set_timestamp(timestamp_helper_->GetTimestamp());

chromecast/media/cma/backend/multizone_backend_unittest.cc

@@ -267,8 +267,8 @@ void BufferFeeder::FeedBuffer() {
         size_bytes / (config_.bytes_per_channel * config_.channel_number);
     last_push_length_us_ = num_samples * base::Time::kMicrosecondsPerSecond /
                            (config_.samples_per_second * playback_rate_);
-    scoped_refptr<::media::DecoderBuffer> silence_buffer(
-        new ::media::DecoderBuffer(size_bytes));
+    auto silence_buffer =
+        base::MakeRefCounted<::media::DecoderBuffer>(size_bytes);
     memset(silence_buffer->writable_data(), 0, silence_buffer->size());
     pending_buffer_ = new media::DecoderBufferAdapter(silence_buffer);
     pending_buffer_->set_timestamp(base::Microseconds(pushed_us_));

chromecast/media/cma/base/demuxer_stream_for_test.cc

@@ -4,6 +4,7 @@
 
 #include "chromecast/media/cma/base/demuxer_stream_for_test.h"
 
+#include "base/memory/scoped_refptr.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "media/base/media_util.h"
@@ -76,7 +77,7 @@ void DemuxerStreamForTest::DoRead(ReadCB read_cb) {
     return;
   }
 
-  scoped_refptr<::media::DecoderBuffer> buffer(new ::media::DecoderBuffer(16));
+  auto buffer = base::MakeRefCounted<::media::DecoderBuffer>(16);
   buffer->set_timestamp(frame_count_ *
                         base::Milliseconds(kDemuxerStreamForTestFrameDuration));
   frame_count_++;

chromecast/media/cma/test/frame_generator_for_test.cc

@@ -8,6 +8,7 @@
 
 #include <utility>
 
+#include "base/memory/scoped_refptr.h"
 #include "chromecast/media/api/decoder_buffer_base.h"
 #include "chromecast/media/cma/base/decoder_buffer_adapter.h"
 #include "media/base/decoder_buffer.h"
@@ -55,8 +56,7 @@ scoped_refptr<DecoderBufferBase> FrameGeneratorForTest::Generate() {
         new DecoderBufferAdapter(::media::DecoderBuffer::CreateEOSBuffer()));
   }
 
-  scoped_refptr< ::media::DecoderBuffer> buffer(
-      new ::media::DecoderBuffer(frame_spec.size));
+  auto buffer = base::MakeRefCounted<::media::DecoderBuffer>(frame_spec.size);
 
   // Timestamp.
   buffer->set_timestamp(frame_spec.timestamp);

chromeos/components/cdm_factory_daemon/chromeos_cdm_factory.cc

@@ -10,6 +10,7 @@
 #include "base/functional/bind.h"
 #include "base/logging.h"
 #include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/no_destructor.h"
 #include "base/notreached.h"
 #include "base/task/bind_post_task.h"
@@ -389,12 +390,9 @@ void ChromeOsCdmFactory::CreateCdm(
   // Create the adapter that proxies calls between
   // media::ContentDecryptionModule and
   // chromeos::cdm::mojom::ContentDecryptionModule.
-  scoped_refptr<ContentDecryptionModuleAdapter> cdm =
-      base::WrapRefCounted<ContentDecryptionModuleAdapter>(
-          new ContentDecryptionModuleAdapter(
-              std::move(storage), std::move(cros_cdm), session_message_cb,
-              session_closed_cb, session_keys_change_cb,
-              session_expiration_update_cb));
+  auto cdm = base::MakeRefCounted<ContentDecryptionModuleAdapter>(
+      std::move(storage), std::move(cros_cdm), session_message_cb,
+      session_closed_cb, session_keys_change_cb, session_expiration_update_cb);
 
   // Create the OutputProtection interface to pass to the CDM.
   mojo::PendingRemote<cdm::mojom::OutputProtection> output_protection_remote;

chromeos/components/cdm_factory_daemon/content_decryption_module_adapter_unittest.cc

@@ -12,6 +12,7 @@
 #include <algorithm>
 
 #include "base/logging.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/test/mock_callback.h"
 #include "base/test/task_environment.h"
 #include "media/base/decoder_buffer.h"
@@ -136,12 +137,11 @@ class ContentDecryptionModuleAdapterTest : public testing::Test {
     mojo::AssociatedRemote<cdm::mojom::ContentDecryptionModule> daemon_cdm_mojo;
     mock_daemon_cdm_ = std::make_unique<MockDaemonCdm>(
         daemon_cdm_mojo.BindNewEndpointAndPassDedicatedReceiver());
-    cdm_adapter_ = base::WrapRefCounted<ContentDecryptionModuleAdapter>(
-        new ContentDecryptionModuleAdapter(
-            nullptr /* storage */, std::move(daemon_cdm_mojo),
-            mock_session_message_cb_.Get(), mock_session_closed_cb_.Get(),
-            mock_session_keys_change_cb_.Get(),
-            mock_session_expiration_update_cb_.Get()));
+    cdm_adapter_ = base::MakeRefCounted<ContentDecryptionModuleAdapter>(
+        nullptr /* storage */, std::move(daemon_cdm_mojo),
+        mock_session_message_cb_.Get(), mock_session_closed_cb_.Get(),
+        mock_session_keys_change_cb_.Get(),
+        mock_session_expiration_update_cb_.Get());
   }
 
   ~ContentDecryptionModuleAdapterTest() override {

components/mirroring/service/openscreen_session_host.cc

@@ -16,6 +16,7 @@
 #include "base/functional/callback_forward.h"
 #include "base/logging.h"
 #include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/metrics/histogram_functions.h"
 #include "base/no_destructor.h"
 #include "base/strings/strcat.h"
@@ -1116,7 +1117,7 @@ void OpenscreenSessionHost::StartCapturingAudio() {
           SessionError::AUDIO_CAPTURE_ERROR)),
       observer_);
 
-  audio_input_device_ = new media::AudioInputDevice(
+  audio_input_device_ = base::MakeRefCounted<media::AudioInputDevice>(
       std::make_unique<CapturedAudioInput>(
           base::BindRepeating(&OpenscreenSessionHost::CreateAudioStream,
                               base::Unretained(this)),

content/browser/speech/speech_recognition_browsertest.cc

@@ -142,10 +142,9 @@ class MockCapturerSource : public media::AudioCapturerSource {
   MOCK_METHOD1(SetOutputDeviceForAec,
                void(const std::string& output_device_id));
 
- protected:
+ private:
   ~MockCapturerSource() override = default;
 
- private:
   StartCallback start_callback_;
   StopCallback stop_callback_;
   raw_ptr<CaptureCallback, AcrossTasksDanglingUntriaged> capture_callback_;

content/browser/speech/speech_recognizer_impl_unittest.cc

@@ -19,6 +19,7 @@
 #include "base/functional/bind.h"
 #include "base/functional/callback_helpers.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/numerics/byte_conversions.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
@@ -82,7 +83,8 @@ class SpeechRecognizerImplTest : public SpeechRecognitionEventListener,
                                  public testing::Test {
  public:
   SpeechRecognizerImplTest()
-      : audio_capturer_source_(new testing::NiceMock<MockCapturerSource>()),
+      : audio_capturer_source_(
+            base::MakeRefCounted<testing::NiceMock<MockCapturerSource>>()),
         recognition_started_(false),
         recognition_ended_(false),
         result_received_(false),

fuchsia_web/webengine/renderer/web_engine_audio_output_device.cc

@@ -6,11 +6,13 @@
 
 #include "base/fuchsia/fuchsia_logging.h"
 #include "base/logging.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/shared_memory_mapping.h"
 #include "base/memory/writable_shared_memory_region.h"
 #include "base/no_destructor.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/threading/thread.h"
+#include "base/types/pass_key.h"
 #include "media/base/audio_glitch_info.h"
 #include "media/base/audio_timestamp_helper.h"
 
@@ -59,8 +61,8 @@ scoped_refptr<base::SingleThreadTaskRunner> GetDefaultAudioTaskRunner() {
 scoped_refptr<WebEngineAudioOutputDevice> WebEngineAudioOutputDevice::Create(
     fidl::InterfaceHandle<fuchsia::media::AudioConsumer> audio_consumer_handle,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  scoped_refptr<WebEngineAudioOutputDevice> result(
-      new WebEngineAudioOutputDevice(task_runner));
+  auto result = base::MakeRefCounted<WebEngineAudioOutputDevice>(
+      base::PassKey<WebEngineAudioOutputDevice>(), task_runner);
   task_runner->PostTask(
       FROM_HERE,
       base::BindOnce(
@@ -78,6 +80,7 @@ WebEngineAudioOutputDevice::CreateOnDefaultThread(
 }
 
 WebEngineAudioOutputDevice::WebEngineAudioOutputDevice(
+    base::PassKey<WebEngineAudioOutputDevice>,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : task_runner_(std::move(task_runner)) {}
 

fuchsia_web/webengine/renderer/web_engine_audio_output_device.h

@@ -12,10 +12,12 @@
 
 #include "base/memory/raw_ptr.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/shared_memory_mapping.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
+#include "base/types/pass_key.h"
 #include "fuchsia_web/webengine/web_engine_export.h"
 #include "media/base/audio_renderer_sink.h"
 
@@ -43,6 +45,10 @@ class WEB_ENGINE_EXPORT WebEngineAudioOutputDevice
       fidl::InterfaceHandle<fuchsia::media::AudioConsumer>
           audio_consumer_handle);
 
+  WebEngineAudioOutputDevice(
+      base::PassKey<WebEngineAudioOutputDevice>,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
   // AudioRendererSink implementation.
   void Initialize(const media::AudioParameters& params,
                   RenderCallback* callback) override;
@@ -60,8 +66,6 @@ class WEB_ENGINE_EXPORT WebEngineAudioOutputDevice
  private:
   friend class WebEngineAudioOutputDeviceTest;
 
-  explicit WebEngineAudioOutputDevice(
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~WebEngineAudioOutputDevice() override;
 
   void BindAudioConsumerOnAudioThread(

fuchsia_web/webengine/renderer/web_engine_audio_renderer_test.cc

@@ -19,6 +19,7 @@
 #include "base/fuchsia/fuchsia_logging.h"
 #include "base/logging.h"
 #include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/test/bind.h"
 #include "base/test/task_environment.h"
@@ -580,8 +581,7 @@ void WebEngineAudioRendererTestBase::ProduceDemuxerPacket(
     base::TimeDelta duration) {
   // Create a dummy packet that contains just 1 byte.
   const size_t kBufferSize = 1;
-  scoped_refptr<media::DecoderBuffer> buffer =
-      new media::DecoderBuffer(kBufferSize);
+  auto buffer = base::MakeRefCounted<media::DecoderBuffer>(kBufferSize);
   buffer->set_timestamp(demuxer_stream_pos_);
   buffer->set_duration(duration);
   demuxer_stream_pos_ += duration;
@@ -712,8 +712,7 @@ void WebEngineAudioRendererTestBase::TestPcmStream(
   const size_t kNumSamples = 10;
   const size_t kChannels = 2;
   size_t input_buffer_size = kNumSamples * kChannels * bytes_per_sample_input;
-  scoped_refptr<media::DecoderBuffer> buffer =
-      new media::DecoderBuffer(input_buffer_size);
+  auto buffer = base::MakeRefCounted<media::DecoderBuffer>(input_buffer_size);
   buffer->set_timestamp(demuxer_stream_pos_);
   buffer->set_duration(kPacketDuration);
   for (size_t i = 0; i < input_buffer_size; ++i) {

media/audio/alsa/alsa_output.cc

@@ -48,6 +48,7 @@
 #include "base/functional/bind.h"
 #include "base/logging.h"
 #include "base/memory/free_deleter.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/time/default_tick_clock.h"

media/audio/alsa/alsa_output_unittest.cc

@@ -7,16 +7,19 @@
 #pragma allow_unsafe_libc_calls
 #endif
 
+#include "media/audio/alsa/alsa_output.h"
+
 #include <stdint.h>
+
 #include <memory>
 
 #include "base/logging.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/test/test_message_loop.h"
 #include "base/time/time.h"
-#include "media/audio/alsa/alsa_output.h"
 #include "media/audio/alsa/alsa_wrapper.h"
 #include "media/audio/alsa/audio_manager_alsa.h"
 #include "media/audio/alsa/mock_alsa_wrapper.h"

media/audio/audio_input_device.h

@@ -92,7 +92,7 @@ class MEDIA_EXPORT AudioInputDevice : public AudioCapturerSource,
   void SetOutputDeviceForAec(const std::string& output_device_id) override;
 
  private:
-  friend class base::RefCountedThreadSafe<AudioInputDevice>;
+  ~AudioInputDevice() override;
 
   // Our audio thread callback class.  See source file for details.
   class AudioThreadCallback;
@@ -115,8 +115,6 @@ class MEDIA_EXPORT AudioInputDevice : public AudioCapturerSource,
     kMaxValue = kErrorDuringCapture
   };
 
-  ~AudioInputDevice() override;
-
   // AudioInputIPCDelegate implementation.
   void OnStreamCreated(base::UnsafeSharedMemoryRegion shared_memory_region,
                        base::SyncSocket::ScopedHandle socket_handle,

media/audio/audio_input_device_unittest.cc

@@ -12,6 +12,7 @@
 #include <utility>
 
 #include "base/memory/ptr_util.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/unsafe_shared_memory_region.h"
 #include "base/process/process_handle.h"
 #include "base/run_loop.h"
@@ -173,9 +174,9 @@ TEST_P(AudioInputDeviceTest, Noop) {
   base::test::SingleThreadTaskEnvironment task_environment(
       base::test::SingleThreadTaskEnvironment::MainThreadType::IO);
   MockAudioInputIPC* input_ipc = new MockAudioInputIPC();
-  scoped_refptr<AudioInputDevice> device(new AudioInputDevice(
+  auto device = base::MakeRefCounted<AudioInputDevice>(
       base::WrapUnique(input_ipc), AudioInputDevice::Purpose::kUserInput,
-      AudioInputDeviceTest::GetParam()));
+      AudioInputDeviceTest::GetParam());
 }
 
 ACTION_P(ReportStateChange, device) {
@@ -190,9 +191,9 @@ TEST_P(AudioInputDeviceTest, FailToCreateStream) {
 
   MockCaptureCallback callback;
   MockAudioInputIPC* input_ipc = new MockAudioInputIPC();
-  scoped_refptr<AudioInputDevice> device(new AudioInputDevice(
+  auto device = base::MakeRefCounted<AudioInputDevice>(
       base::WrapUnique(input_ipc), AudioInputDevice::Purpose::kUserInput,
-      AudioInputDeviceTest::GetParam()));
+      AudioInputDeviceTest::GetParam());
   device->Initialize(params, &callback);
   EXPECT_CALL(*input_ipc, CreateStream(_, _, _, _))
       .WillOnce(ReportStateChange(device.get()));

media/audio/audio_output_device.h

@@ -131,13 +131,11 @@ class MEDIA_EXPORT AudioOutputDevice : public AudioRendererSink,
 
   AudioOutputIPC* GetIpcForTesting() { return ipc_.get(); }
 
- protected:
-  // Magic required by ref_counted.h to avoid any code deleting the object
+ private:
+  // Required by ref_counted.h to avoid any code deleting the object
   // accidentally while there are references to it.
-  friend class base::RefCountedThreadSafe<AudioOutputDevice>;
   ~AudioOutputDevice() override;
 
- private:
   enum StartupState {
     IDLE,                       // Authorization not requested.
     AUTHORIZATION_REQUESTED,    // Sent (possibly completed) device

media/audio/audio_output_device_unittest.cc

@@ -150,7 +150,7 @@ void AudioOutputDeviceTest::CreateDevice(const std::string& device_id,
   if (audio_device_)
     StopAudioDevice();
 
-  audio_device_ = new AudioOutputDevice(
+  audio_device_ = base::MakeRefCounted<AudioOutputDevice>(
       std::make_unique<NiceMock<MockAudioOutputIPC>>(),
       task_env_.GetMainThreadTaskRunner(),
       AudioSinkParameters(base::UnguessableToken(), device_id), timeout);
@@ -362,7 +362,7 @@ TEST_F(AudioOutputDeviceTest,
 TEST_F(AudioOutputDeviceTest, AuthorizationFailsBeforeInitialize_NoError) {
   // Clear audio device set by fixture.
   StopAudioDevice();
-  audio_device_ = new AudioOutputDevice(
+  audio_device_ = base::MakeRefCounted<AudioOutputDevice>(
       std::make_unique<NiceMock<MockAudioOutputIPC>>(),
       task_env_.GetMainThreadTaskRunner(),
       AudioSinkParameters(base::UnguessableToken(), kDefaultDeviceId),

media/audio/audio_thread_hang_monitor.h

@@ -86,6 +86,8 @@ class MEDIA_EXPORT AudioThreadHangMonitor final {
   class SharedAtomicFlag final
       : public base::RefCountedThreadSafe<SharedAtomicFlag> {
    public:
+    REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
     SharedAtomicFlag();
 
     std::atomic_bool flag_ = {false};

media/audio/clockless_audio_sink.h

@@ -50,10 +50,9 @@ class MEDIA_EXPORT ClocklessAudioSink : public AudioRendererSink {
 
   void SetIsOptimizedForHardwareParametersForTesting(bool value);
 
- protected:
+ private:
   ~ClocklessAudioSink() override;
 
- private:
   const OutputDeviceInfo device_info_;
   std::unique_ptr<ClocklessAudioSinkThread> thread_;
   bool initialized_;

media/audio/mac/audio_loopback_input_mac_impl.mm

@@ -39,6 +39,8 @@ constexpr float kMaxVolume = 1.0;
 class API_AVAILABLE(macos(13.0)) SharedHelper
     : public base::RefCountedThreadSafe<SharedHelper> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   SharedHelper(const base::TimeDelta shareable_content_timeout)
       : volume_(kMaxVolume),
         shareable_content_timeout_(shareable_content_timeout) {}
@@ -140,10 +142,13 @@ class API_AVAILABLE(macos(13.0)) SharedHelper
 
  private:
   friend class base::RefCountedThreadSafe<SharedHelper>;
+  ~SharedHelper() = default;
 
   class ShareableContentData
       : public base::RefCountedThreadSafe<ShareableContentData> {
    public:
+    REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
     // Event used to signal completion of shareable content enumeration.
     base::WaitableEvent event;
 
@@ -159,8 +164,6 @@ class API_AVAILABLE(macos(13.0)) SharedHelper
     ~ShareableContentData() = default;
   };
 
-  ~SharedHelper() = default;
-
   // Invoked when shareable content (displays, applications, windows) has been
   // enumerated. Generates a filter based on the available content. Runs on a
   // SCK thread.

media/audio/null_audio_sink.h

@@ -49,10 +49,9 @@ class MEDIA_EXPORT NullAudioSink : public SwitchableAudioRendererSink {
   // Returns the hash of all audio frames seen since construction.
   const AudioHash& GetAudioHashForTesting() const;
 
- protected:
+ private:
   ~NullAudioSink() override;
 
- private:
   // Task that periodically calls Render() to consume audio data.
   void CallRender(base::TimeTicks ideal_time, base::TimeTicks now);
 

media/base/android/android_cdm_factory.cc

@@ -7,6 +7,7 @@
 #include "base/feature_list.h"
 #include "base/functional/bind.h"
 #include "base/logging.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task/bind_post_task.h"
@@ -61,9 +62,10 @@ void AndroidCdmFactory::Create(
   // TODO (b/263310318) Remove AesDecryptor once ClearKey on Android is fixed.
   if (base::FeatureList::IsEnabled(media::kExternalClearKeyForTesting) &&
       IsExternalClearKey(cdm_config.key_system)) {
-    scoped_refptr<ContentDecryptionModule> cdm(
-        new AesDecryptor(session_message_cb, session_closed_cb,
-                         session_keys_change_cb, session_expiration_update_cb));
+    scoped_refptr<ContentDecryptionModule> cdm =
+        base::MakeRefCounted<AesDecryptor>(
+            session_message_cb, session_closed_cb, session_keys_change_cb,
+            session_expiration_update_cb);
     std::move(bound_cdm_created_cb).Run(cdm, CreateCdmStatus::kSuccess);
     return;
   }

media/base/audio_buffer.h

@@ -309,6 +309,8 @@ class MEDIA_EXPORT AudioBuffer
 class MEDIA_EXPORT AudioBufferMemoryPool
     : public base::RefCountedThreadSafe<AudioBufferMemoryPool> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   explicit AudioBufferMemoryPool(int alignment = AudioBus::kChannelAlignment);
   AudioBufferMemoryPool(const AudioBufferMemoryPool&) = delete;
   AudioBufferMemoryPool& operator=(const AudioBufferMemoryPool&) = delete;

media/base/audio_buffer_converter.cc

@@ -41,7 +41,7 @@ AudioBufferConverter::AudioBufferConverter(const AudioParameters& output_params)
       io_sample_rate_ratio_(1.0),
       timestamp_helper_(output_params_.sample_rate()),
       is_flushing_(false),
-      pool_(new AudioBufferMemoryPool()) {}
+      pool_(base::MakeRefCounted<AudioBufferMemoryPool>()) {}
 
 AudioBufferConverter::~AudioBufferConverter() = default;
 

media/base/audio_buffer_unittest.cc

@@ -7,14 +7,16 @@
 #pragma allow_unsafe_buffers
 #endif
 
+#include "media/base/audio_buffer.h"
+
 #include <stdint.h>
 
 #include <limits>
 #include <memory>
 
+#include "base/memory/scoped_refptr.h"
 #include "base/test/gtest_util.h"
 #include "base/time/time.h"
-#include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -776,7 +778,7 @@ TEST(AudioBufferTest, TrimRangeInterleaved) {
 }
 
 TEST(AudioBufferTest, AudioBufferMemoryPool) {
-  scoped_refptr<AudioBufferMemoryPool> pool(new AudioBufferMemoryPool());
+  auto pool = base::MakeRefCounted<AudioBufferMemoryPool>();
   EXPECT_EQ(0u, pool->GetPoolSizeForTesting());
 
   const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_MONO;
@@ -828,8 +830,7 @@ TEST(AudioBufferTest, AudioBufferMemoryPoolAlignment) {
   const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_6_1;
   const size_t kChannelCount = ChannelLayoutToChannelCount(kChannelLayout);
 
-  scoped_refptr<AudioBufferMemoryPool> pool(
-      new AudioBufferMemoryPool(kAlignment));
+  auto pool = base::MakeRefCounted<AudioBufferMemoryPool>(kAlignment);
   scoped_refptr<AudioBuffer> buffer =
       AudioBuffer::CreateBuffer(kSampleFormatPlanarU8, kChannelLayout,
                                 kChannelCount, kSampleRate, kSampleRate, pool);
@@ -864,7 +865,7 @@ TEST(AudioBufferTest, AudioBufferAlignmentUnpooled) {
 
 // Planar allocations use a different path, so make sure pool is used.
 TEST(AudioBufferTest, AudioBufferMemoryPoolPlanar) {
-  scoped_refptr<AudioBufferMemoryPool> pool(new AudioBufferMemoryPool());
+  auto pool = base::MakeRefCounted<AudioBufferMemoryPool>();
   EXPECT_EQ(0u, pool->GetPoolSizeForTesting());
 
   const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_MONO;

media/base/audio_capturer_source.h

@@ -28,6 +28,8 @@ struct AudioGlitchInfo;
 class AudioCapturerSource
     : public base::RefCountedThreadSafe<media::AudioCapturerSource> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   enum class ErrorCode {
     kUnknown = 0,
     kSystemPermissions = 1,
@@ -92,7 +94,7 @@ class AudioCapturerSource
 
  protected:
   friend class base::RefCountedThreadSafe<AudioCapturerSource>;
-  virtual ~AudioCapturerSource() {}
+  virtual ~AudioCapturerSource() = default;
 };
 
 }  // namespace media

media/base/audio_renderer_sink.h

@@ -26,6 +26,8 @@ struct AudioGlitchInfo;
 class AudioRendererSink
     : public base::RefCountedThreadSafe<media::AudioRendererSink> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   class RenderCallback {
    public:
     // Attempts to completely fill all channels of |dest|, returns actual
@@ -104,7 +106,7 @@ class AudioRendererSink
 
  protected:
   friend class base::RefCountedThreadSafe<AudioRendererSink>;
-  virtual ~AudioRendererSink() {}
+  virtual ~AudioRendererSink() = default;
 };
 
 // Same as AudioRendererSink except that Initialize() and Start() can be called
@@ -114,7 +116,7 @@ class AudioRendererSink
 
 class RestartableAudioRendererSink : public AudioRendererSink {
  protected:
-  ~RestartableAudioRendererSink() override {}
+  ~RestartableAudioRendererSink() override = default;
 };
 
 class SwitchableAudioRendererSink : public RestartableAudioRendererSink {
@@ -128,7 +130,7 @@ class SwitchableAudioRendererSink : public RestartableAudioRendererSink {
                                   OutputDeviceStatusCB callback) = 0;
 
  protected:
-  ~SwitchableAudioRendererSink() override {}
+  ~SwitchableAudioRendererSink() override = default;
 };
 
 }  // namespace media

media/base/content_decryption_module.h

@@ -110,6 +110,8 @@ class MEDIA_EXPORT ContentDecryptionModule
     : public base::RefCountedThreadSafe<ContentDecryptionModule,
                                         ContentDecryptionModuleTraits> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   ContentDecryptionModule(const ContentDecryptionModule&) = delete;
   ContentDecryptionModule& operator=(const ContentDecryptionModule&) = delete;
 

media/base/data_buffer.cc

@@ -6,6 +6,9 @@
 
 #include <utility>
 
+#include "base/memory/scoped_refptr.h"
+#include "base/types/pass_key.h"
+
 namespace media {
 
 DataBuffer::DataBuffer(size_t capacity) {
@@ -17,23 +20,27 @@ DataBuffer::DataBuffer(base::HeapArray<uint8_t> buffer) : size_(buffer.size()) {
   CHECK(data_.data());
 }
 
-DataBuffer::DataBuffer(base::span<const uint8_t> data) : size_(data.size()) {
+DataBuffer::DataBuffer(base::PassKey<DataBuffer>,
+                       base::span<const uint8_t> data)
+    : size_(data.size()) {
   CHECK(!data.empty());
   data_ = base::HeapArray<uint8_t>::CopiedFrom(data);
 }
-DataBuffer::DataBuffer(DataBufferType data_buffer_type)
+DataBuffer::DataBuffer(base::PassKey<DataBuffer>,
+                       DataBufferType data_buffer_type)
     : is_end_of_stream_(data_buffer_type == DataBufferType::kEndOfStream) {}
 
 DataBuffer::~DataBuffer() = default;
 
 // static
 scoped_refptr<DataBuffer> DataBuffer::CopyFrom(base::span<const uint8_t> data) {
-  return base::WrapRefCounted(new DataBuffer(data));
+  return base::MakeRefCounted<DataBuffer>(base::PassKey<DataBuffer>(), data);
 }
 
 // static
 scoped_refptr<DataBuffer> DataBuffer::CreateEOSBuffer() {
-  return base::WrapRefCounted(new DataBuffer(DataBufferType::kEndOfStream));
+  return base::MakeRefCounted<DataBuffer>(base::PassKey<DataBuffer>(),
+                                          DataBufferType::kEndOfStream);
 }
 
 void DataBuffer::Append(base::span<const uint8_t> data) {

media/base/data_buffer.h

@@ -12,6 +12,7 @@
 #include "base/containers/span.h"
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
+#include "base/types/pass_key.h"
 #include "media/base/media_export.h"
 
 namespace media {
@@ -26,6 +27,8 @@ namespace media {
 // NOTE: It is illegal to call any method when end_of_stream() is true.
 class MEDIA_EXPORT DataBuffer : public base::RefCountedThreadSafe<DataBuffer> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   // Constructs an empty buffer with max `capacity`, uninitialized `data_` and
   // a size of zero.
   explicit DataBuffer(size_t capacity);
@@ -34,6 +37,12 @@ class MEDIA_EXPORT DataBuffer : public base::RefCountedThreadSafe<DataBuffer> {
   // with a size of `buffer.size()`.
   explicit DataBuffer(base::HeapArray<uint8_t> buffer);
 
+  // Allocates a buffer with a copy of `data` in it
+  DataBuffer(base::PassKey<DataBuffer>, base::span<const uint8_t> data);
+
+  enum class DataBufferType { kNormal, kEndOfStream };
+  DataBuffer(base::PassKey<DataBuffer>, DataBufferType data_buffer_type);
+
   DataBuffer(DataBuffer&&) = delete;
   DataBuffer(const DataBuffer&) = delete;
   DataBuffer& operator=(DataBuffer&&) = delete;
@@ -115,18 +124,10 @@ class MEDIA_EXPORT DataBuffer : public base::RefCountedThreadSafe<DataBuffer> {
 
   bool end_of_stream() const { return is_end_of_stream_; }
 
- protected:
+ private:
   friend class base::RefCountedThreadSafe<DataBuffer>;
-  enum class DataBufferType { kNormal, kEndOfStream };
-
-  // Allocates a buffer with a copy of |data| in it
-  explicit DataBuffer(base::span<const uint8_t> data);
-
-  explicit DataBuffer(DataBufferType data_buffer_type);
-
   virtual ~DataBuffer();
 
- private:
   base::TimeDelta timestamp_;
   base::TimeDelta duration_;
 

media/base/data_buffer_unittest.cc

@@ -9,6 +9,7 @@
 #include <memory>
 #include <utility>
 
+#include "base/memory/scoped_refptr.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"

media/base/decoder_buffer.cc

@@ -8,7 +8,9 @@
 
 #include "base/containers/heap_array.h"
 #include "base/debug/alias.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/strings/stringprintf.h"
+#include "base/types/pass_key.h"
 #include "media/base/subsample_entry.h"
 
 namespace media {
@@ -54,18 +56,37 @@ DecoderBuffer::DecoderBuffer(DecoderBufferType decoder_buffer_type,
   }
 }
 
+DecoderBuffer::DecoderBuffer(base::PassKey<DecoderBuffer>,
+                             base::span<const uint8_t> data)
+    : DecoderBuffer(std::move(data)) {}
+
+DecoderBuffer::DecoderBuffer(base::PassKey<DecoderBuffer>,
+                             base::HeapArray<uint8_t> data)
+    : DecoderBuffer(std::move(data)) {}
+
+DecoderBuffer::DecoderBuffer(base::PassKey<DecoderBuffer>,
+                             std::unique_ptr<ExternalMemory> external_memory)
+    : DecoderBuffer(std::move(external_memory)) {}
+
+DecoderBuffer::DecoderBuffer(base::PassKey<DecoderBuffer>,
+                             DecoderBufferType decoder_buffer_type,
+                             std::optional<ConfigVariant> next_config)
+    : DecoderBuffer(decoder_buffer_type, std::move(next_config)) {}
+
 DecoderBuffer::~DecoderBuffer() = default;
 
 // static
 scoped_refptr<DecoderBuffer> DecoderBuffer::CopyFrom(
     base::span<const uint8_t> data) {
-  return base::WrapRefCounted(new DecoderBuffer(data));
+  return base::MakeRefCounted<DecoderBuffer>(base::PassKey<DecoderBuffer>(),
+                                             data);
 }
 
 // static
 scoped_refptr<DecoderBuffer> DecoderBuffer::FromArray(
     base::HeapArray<uint8_t> data) {
-  return base::WrapRefCounted(new DecoderBuffer(std::move(data)));
+  return base::MakeRefCounted<DecoderBuffer>(base::PassKey<DecoderBuffer>(),
+                                             std::move(data));
 }
 
 // static
@@ -114,14 +135,16 @@ scoped_refptr<DecoderBuffer> DecoderBuffer::FromExternalMemory(
   if (external_memory->Span().empty()) {
     return nullptr;
   }
-  return base::WrapRefCounted(new DecoderBuffer(std::move(external_memory)));
+  return base::MakeRefCounted<DecoderBuffer>(base::PassKey<DecoderBuffer>(),
+                                             std::move(external_memory));
 }
 
 // static
 scoped_refptr<DecoderBuffer> DecoderBuffer::CreateEOSBuffer(
     std::optional<ConfigVariant> next_config) {
-  return base::WrapRefCounted(new DecoderBuffer(DecoderBufferType::kEndOfStream,
-                                                std::move(next_config)));
+  return base::MakeRefCounted<DecoderBuffer>(base::PassKey<DecoderBuffer>(),
+                                             DecoderBufferType::kEndOfStream,
+                                             std::move(next_config));
 }
 
 // static

media/base/decoder_buffer.h

@@ -23,6 +23,7 @@
 #include "base/memory/shared_memory_mapping.h"
 #include "base/memory/unsafe_shared_memory_region.h"
 #include "base/time/time.h"
+#include "base/types/pass_key.h"
 #include "build/build_config.h"
 #include "media/base/decoder_buffer_side_data.h"
 #include "media/base/decrypt_config.h"
@@ -39,6 +40,8 @@ namespace media {
 class MEDIA_EXPORT DecoderBuffer
     : public base::RefCountedThreadSafe<DecoderBuffer> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   // ExternalMemory wraps a class owning a buffer and expose the data interface
   // through Span(). This class is derived by a class that owns the class owning
   // the buffer owner class.
@@ -72,6 +75,17 @@ class MEDIA_EXPORT DecoderBuffer
   // FromArray constructor instead asking for a writable DecoderBuffer.
   explicit DecoderBuffer(size_t size);
 
+  // Allocates a buffer with a copy of `data` in it. `is_key_frame_` will
+  // default to false.
+  DecoderBuffer(base::PassKey<DecoderBuffer>, base::span<const uint8_t> data);
+  DecoderBuffer(base::PassKey<DecoderBuffer>, base::HeapArray<uint8_t> data);
+  DecoderBuffer(base::PassKey<DecoderBuffer>,
+                std::unique_ptr<ExternalMemory> external_memory);
+  enum class DecoderBufferType { kNormal, kEndOfStream };
+  using ConfigVariant = DecoderBufferSideData::ConfigVariant;
+  DecoderBuffer(base::PassKey<DecoderBuffer>,
+                DecoderBufferType decoder_buffer_type,
+                std::optional<ConfigVariant> next_config);
   DecoderBuffer(const DecoderBuffer&) = delete;
   DecoderBuffer& operator=(const DecoderBuffer&) = delete;
 
@@ -119,7 +133,6 @@ class MEDIA_EXPORT DecoderBuffer
   //
   // Calling any method other than end_of_stream() or next_config() on the
   // resulting buffer is disallowed.
-  using ConfigVariant = DecoderBufferSideData::ConfigVariant;
   static scoped_refptr<DecoderBuffer> CreateEOSBuffer(
       std::optional<ConfigVariant> next_config = std::nullopt);
 
@@ -280,21 +293,16 @@ class MEDIA_EXPORT DecoderBuffer
 
  protected:
   friend class base::RefCountedThreadSafe<DecoderBuffer>;
-  enum class DecoderBufferType { kNormal, kEndOfStream };
+  virtual ~DecoderBuffer();
 
-  // Allocates a buffer with a copy of |data| in it. |is_key_frame_| will
+  // Allocates a buffer with a copy of `data` in it. `is_key_frame_` will
   // default to false.
   explicit DecoderBuffer(base::span<const uint8_t> data);
-
   explicit DecoderBuffer(base::HeapArray<uint8_t> data);
-
   explicit DecoderBuffer(std::unique_ptr<ExternalMemory> external_memory);
-
   DecoderBuffer(DecoderBufferType decoder_buffer_type,
                 std::optional<ConfigVariant> next_config);
 
-  virtual ~DecoderBuffer();
-
   // Encoded data, if it is stored on the heap.
   const base::HeapArray<uint8_t> data_;
 

media/base/decoder_buffer_queue_unittest.cc

@@ -2,8 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "media/base/decoder_buffer.h"
 #include "media/base/decoder_buffer_queue.h"
+
+#include "base/memory/scoped_refptr.h"
+#include "media/base/decoder_buffer.h"
 #include "media/base/timestamp_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -19,14 +21,14 @@ static base::TimeDelta ToTimeDelta(int seconds) {
 //
 // Negative numbers will be converted to kNoTimestamp;
 static scoped_refptr<DecoderBuffer> CreateBuffer(int timestamp) {
-  scoped_refptr<DecoderBuffer> buffer = new DecoderBuffer(0);
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(0);
   buffer->set_timestamp(ToTimeDelta(timestamp));
   buffer->set_duration(ToTimeDelta(0));
   return buffer;
 }
 
 static scoped_refptr<DecoderBuffer> CreateBuffer(int timestamp, int size) {
-  scoped_refptr<DecoderBuffer> buffer = new DecoderBuffer(size);
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(size);
   buffer->set_timestamp(ToTimeDelta(timestamp));
   buffer->set_duration(ToTimeDelta(0));
   return buffer;

media/base/decoder_buffer_unittest.cc

@@ -16,6 +16,7 @@
 
 #include "base/containers/heap_array.h"
 #include "base/memory/read_only_shared_memory_region.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/unsafe_shared_memory_region.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
@@ -26,7 +27,7 @@
 namespace media {
 
 TEST(DecoderBufferTest, Constructors) {
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(0));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(0);
   EXPECT_FALSE(buffer->data());
   EXPECT_EQ(0u, buffer->size());
   EXPECT_TRUE(buffer->empty());
@@ -35,7 +36,7 @@ TEST(DecoderBufferTest, Constructors) {
   EXPECT_FALSE(buffer->is_key_frame());
 
   const size_t kTestSize = 10;
-  scoped_refptr<DecoderBuffer> buffer3(new DecoderBuffer(kTestSize));
+  auto buffer3 = base::MakeRefCounted<DecoderBuffer>(kTestSize);
   ASSERT_TRUE(buffer3.get());
   EXPECT_EQ(kTestSize, buffer3->size());
   EXPECT_FALSE(buffer3->empty());
@@ -210,7 +211,7 @@ TEST(DecoderBufferTest, ReadingWriting) {
   const uint8_t kData[] = "hello";
   const size_t kDataSize = std::size(kData);
 
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(kDataSize));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(kDataSize);
   ASSERT_TRUE(buffer.get());
 
   uint8_t* data = buffer->writable_data();
@@ -224,7 +225,7 @@ TEST(DecoderBufferTest, ReadingWriting) {
 }
 
 TEST(DecoderBufferTest, DecryptConfig) {
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(0));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(0);
   EXPECT_FALSE(buffer->decrypt_config());
 
   const char kKeyId[] = "key id";
@@ -244,7 +245,7 @@ TEST(DecoderBufferTest, DecryptConfig) {
 }
 
 TEST(DecoderBufferTest, IsKeyFrame) {
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(0));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(0);
   EXPECT_FALSE(buffer->is_key_frame());
 
   buffer->set_is_key_frame(false);
@@ -255,7 +256,7 @@ TEST(DecoderBufferTest, IsKeyFrame) {
 }
 
 TEST(DecoderBufferTest, SideData) {
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(0));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(0);
   EXPECT_FALSE(buffer->side_data());
 
   constexpr uint64_t kSecureHandle = 42;
@@ -285,7 +286,7 @@ TEST(DecoderBufferTest, SideData) {
 }
 
 TEST(DecoderBufferTest, IsEncrypted) {
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(0));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(0);
   EXPECT_FALSE(buffer->is_encrypted());
 
   const char kKeyId[] = "key id";

media/base/fake_audio_renderer_sink.h

@@ -60,10 +60,9 @@ class FakeAudioRendererSink : public AudioRendererSink {
 
   State state() const { return state_; }
 
- protected:
+ private:
   ~FakeAudioRendererSink() override;
 
- private:
   void ChangeState(State new_state);
 
   State state_;

media/base/fake_audio_worker.cc

@@ -11,6 +11,7 @@
 #include "base/functional/bind.h"
 #include "base/functional/callback_helpers.h"
 #include "base/location.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/synchronization/lock.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/task/single_thread_task_runner.h"
@@ -26,6 +27,8 @@ namespace media {
 class FakeAudioWorker::Worker
     : public base::RefCountedThreadSafe<FakeAudioWorker::Worker> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   Worker(const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
          const AudioParameters& params);
 
@@ -69,7 +72,7 @@ class FakeAudioWorker::Worker
 FakeAudioWorker::FakeAudioWorker(
     const scoped_refptr<base::SequencedTaskRunner>& worker_task_runner,
     const AudioParameters& params)
-    : worker_(new Worker(worker_task_runner, params)) {}
+    : worker_(base::MakeRefCounted<Worker>(worker_task_runner, params)) {}
 
 FakeAudioWorker::~FakeAudioWorker() {
   DCHECK(worker_->IsStopped());

media/base/frame_buffer_pool.h

@@ -26,6 +26,8 @@ namespace media {
 class MEDIA_EXPORT FrameBufferPool
     : public base::RefCountedThreadSafe<FrameBufferPool> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   // Must be called on the same thread that `Shutdown()` is called on.  If
   // `zero_initialize_memory` is true, then initial allocations will be
   // cleared.  This does not affect reused buffers, which are never cleared.

media/base/media_log.cc

@@ -8,6 +8,7 @@
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "media/base/media_switches.h"
@@ -19,7 +20,7 @@ namespace media {
 // only in one spot.
 const char MediaLog::kEventKey[] = "event";
 
-MediaLog::MediaLog() : MediaLog(new ParentLogRecord(this)) {}
+MediaLog::MediaLog() : MediaLog(base::MakeRefCounted<ParentLogRecord>(this)) {}
 
 MediaLog::MediaLog(scoped_refptr<ParentLogRecord> parent_log_record)
     : parent_log_record_(std::move(parent_log_record)) {}

media/base/media_log.h

@@ -180,6 +180,8 @@ class MEDIA_EXPORT MediaLog {
   void InvalidateLog();
 
   struct ParentLogRecord : base::RefCountedThreadSafe<ParentLogRecord> {
+    REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
     explicit ParentLogRecord(MediaLog* log);
 
     ParentLogRecord(const ParentLogRecord&) = delete;

media/base/silent_sink_suspender_unittest.cc

@@ -9,6 +9,7 @@
 
 #include "media/base/silent_sink_suspender.h"
 
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
 #include "base/test/gmock_callback_support.h"
 #include "base/test/test_message_loop.h"
@@ -28,7 +29,8 @@ class SilentSinkSuspenderTest : public testing::Test {
                 ChannelLayoutConfig::Mono(),
                 44100,
                 128),
-        mock_sink_(new testing::StrictMock<MockAudioRendererSink>()),
+        mock_sink_(
+            base::MakeRefCounted<testing::StrictMock<MockAudioRendererSink>>()),
         fake_callback_(0.1, params_.sample_rate()),
         temp_bus_(AudioBus::Create(params_)),
         // Set a negative timeout so any silence will suspend immediately.

media/base/test_data_util.cc

@@ -17,9 +17,11 @@
 #include "base/check_op.h"
 #include "base/containers/flat_map.h"
 #include "base/files/file_util.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/no_destructor.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/path_service.h"
+#include "media/base/decoder_buffer.h"
 
 namespace media {
 
@@ -238,7 +240,7 @@ scoped_refptr<DecoderBuffer> ReadTestDataFile(std::string_view name) {
 
   int file_size = base::checked_cast<int>(tmp.value());
 
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(file_size));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(file_size);
   auto* data = reinterpret_cast<char*>(buffer->writable_data());
   CHECK_EQ(file_size, base::ReadFile(file_path, data, file_size))
       << "Failed to read '" << name << "'";

media/base/test_helpers.cc

@@ -16,6 +16,8 @@
 
 #include "base/check_op.h"
 #include "base/functional/bind.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/notreached.h"
 #include "base/pickle.h"
 #include "base/run_loop.h"
@@ -246,8 +248,9 @@ void FillFourColorsFrameARGB(VideoFrame& dest_frame,
 // Utility mock for testing methods expecting Closures and PipelineStatusCBs.
 class MockCallback : public base::RefCountedThreadSafe<MockCallback> {
  public:
-  MockCallback();
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
 
+  MockCallback() = default;
   MockCallback(const MockCallback&) = delete;
   MockCallback& operator=(const MockCallback&) = delete;
 
@@ -257,28 +260,25 @@ class MockCallback : public base::RefCountedThreadSafe<MockCallback> {
 
  protected:
   friend class base::RefCountedThreadSafe<MockCallback>;
-  virtual ~MockCallback();
+  virtual ~MockCallback() = default;
 };
 
-MockCallback::MockCallback() = default;
-MockCallback::~MockCallback() = default;
-
 base::OnceClosure NewExpectedClosure() {
-  StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
+  auto callback = base::MakeRefCounted<StrictMock<MockCallback>>();
   EXPECT_CALL(*callback, Run());
-  return base::BindOnce(&MockCallback::Run, WrapRefCounted(callback));
+  return base::BindOnce(&MockCallback::Run, std::move(callback));
 }
 
 base::OnceCallback<void(bool)> NewExpectedBoolCB(bool success) {
-  StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
+  auto callback = base::MakeRefCounted<StrictMock<MockCallback>>();
   EXPECT_CALL(*callback, RunWithBool(success));
-  return base::BindOnce(&MockCallback::RunWithBool, WrapRefCounted(callback));
+  return base::BindOnce(&MockCallback::RunWithBool, std::move(callback));
 }
 
 PipelineStatusCallback NewExpectedStatusCB(PipelineStatus status) {
-  StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
+  auto callback = base::MakeRefCounted<StrictMock<MockCallback>>();
   EXPECT_CALL(*callback, RunWithStatus(status));
-  return base::BindOnce(&MockCallback::RunWithStatus, WrapRefCounted(callback));
+  return base::BindOnce(&MockCallback::RunWithStatus, std::move(callback));
 }
 
 WaitableMessageLoopEvent::WaitableMessageLoopEvent()

media/base/video_frame_pool.cc

@@ -9,6 +9,7 @@
 #include "base/logging.h"
 #include "base/memory/raw_ptr.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_annotations.h"
 #include "base/time/default_tick_clock.h"
@@ -19,6 +20,8 @@ namespace media {
 class VideoFramePool::PoolImpl
     : public base::RefCountedThreadSafe<VideoFramePool::PoolImpl> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   PoolImpl();
   PoolImpl(const PoolImpl&) = delete;
   PoolImpl& operator=(const PoolImpl&) = delete;
@@ -144,7 +147,7 @@ void VideoFramePool::PoolImpl::FrameReleased(scoped_refptr<VideoFrame> frame) {
     frames_.erase(frames_.begin(), frames_.begin() + stale_index);
 }
 
-VideoFramePool::VideoFramePool() : pool_(new PoolImpl()) {}
+VideoFramePool::VideoFramePool() : pool_(base::MakeRefCounted<PoolImpl>()) {}
 
 VideoFramePool::~VideoFramePool() {
   pool_->Shutdown();

media/base/win/media_foundation_cdm_proxy.h

@@ -20,6 +20,8 @@ namespace media {
 class MediaFoundationCdmProxy
     : public base::RefCountedThreadSafe<MediaFoundationCdmProxy> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   // Used by MediaFoundationProtectionManager to get
   // ABI::Windows::Media::Protection::IMediaProtectionPMPServer to implement
   // ABI::Windows::Media::Protection::IMediaProtectionManager::get_Properties

media/cdm/aes_decryptor_unittest.cc

@@ -21,6 +21,7 @@
 #include "base/functional/bind.h"
 #include "base/json/json_reader.h"
 #include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/task_environment.h"
@@ -260,7 +261,7 @@ class AesDecryptorTest : public testing::TestWithParam<TestType> {
   void SetUp() override {
     if (GetParam() == TestType::kAesDecryptor) {
       OnCdmCreated(
-          new AesDecryptor(
+          base::MakeRefCounted<AesDecryptor>(
               base::BindRepeating(&MockCdmClient::OnSessionMessage,
                                   base::Unretained(&cdm_client_)),
               base::BindRepeating(&MockCdmClient::OnSessionClosed,

media/cdm/cdm_adapter.cc

@@ -248,7 +248,7 @@ CdmAdapter::CdmAdapter(
       scoped_crash_key_(&g_origin_crash_key,
                         helper_->GetCdmOrigin().Serialize()),
       task_runner_(base::SingleThreadTaskRunner::GetCurrentDefault()),
-      pool_(new AudioBufferMemoryPool()) {
+      pool_(base::MakeRefCounted<AudioBufferMemoryPool>()) {
   DVLOG(1) << __func__;
 
   DCHECK(!cdm_config.key_system.empty());

media/mojo/clients/mojo_audio_decoder_unittest.cc

@@ -2,11 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "media/mojo/clients/mojo_audio_decoder.h"
+
 #include <memory>
 
 #include "base/functional/bind.h"
 #include "base/functional/callback_helpers.h"
 #include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/test/gmock_callback_support.h"
@@ -20,7 +23,6 @@
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
 #include "media/base/waiting.h"
-#include "media/mojo/clients/mojo_audio_decoder.h"
 #include "media/mojo/mojom/audio_decoder.mojom.h"
 #include "media/mojo/services/mojo_audio_decoder_service.h"
 #include "media/mojo/services/mojo_cdm_service_context.h"
@@ -194,7 +196,7 @@ class MojoAudioDecoderTest : public ::testing::Test {
   void Initialize() { InitializeAndExpect(DecoderStatus::Codes::kOk); }
 
   void Decode() {
-    scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
+    auto buffer = base::MakeRefCounted<DecoderBuffer>(100);
     mojo_audio_decoder_->Decode(
         buffer, base::BindRepeating(&MojoAudioDecoderTest::OnDecoded,
                                     base::Unretained(this)));

media/mojo/clients/mojo_audio_encoder.cc

@@ -45,7 +45,7 @@ bool MojoAudioEncoder::IsSupported(AudioCodec codec) {
 MojoAudioEncoder::MojoAudioEncoder(
     mojo::PendingRemote<mojom::AudioEncoder> remote_encoder)
     : pending_remote_encoder_(std::move(remote_encoder)),
-      buffer_pool_(new AudioBufferMemoryPool()),
+      buffer_pool_(base::MakeRefCounted<AudioBufferMemoryPool>()),
       runner_(base::SequencedTaskRunner::GetCurrentDefault()) {
   weak_this_ = weak_factory_.GetWeakPtr();
 }

media/mojo/clients/mojo_cdm_factory.cc

@@ -77,9 +77,9 @@ void MojoCdmFactory::Create(
   // Note: Previously MojoRenderer doesn't work with local CDMs, this has
   // been solved by using DecryptingRenderer. See http://crbug.com/913775.
   if (key_systems_->CanUseAesDecryptor(cdm_config.key_system)) {
-    scoped_refptr<ContentDecryptionModule> cdm(
-        new AesDecryptor(session_message_cb, session_closed_cb,
-                         session_keys_change_cb, session_expiration_update_cb));
+    auto cdm = base::MakeRefCounted<AesDecryptor>(
+        session_message_cb, session_closed_cb, session_keys_change_cb,
+        session_expiration_update_cb);
     base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
         FROM_HERE, base::BindOnce(std::move(cdm_created_cb), cdm,
                                   CreateCdmStatus::kSuccess));

media/mojo/clients/mojo_cdm_unittest.cc

@@ -369,7 +369,7 @@ class MojoCdmTest : public ::testing::Test {
   base::TestMessageLoop message_loop_;
 
   // |remote_cdm_| represents the CDM at the end of the mojo message pipe.
-  scoped_refptr<MockCdm> remote_cdm_{new MockCdm()};
+  scoped_refptr<MockCdm> remote_cdm_{base::MakeRefCounted<MockCdm>()};
   MockCdmFactory cdm_factory_{remote_cdm_};
   MockCdmContext cdm_context_;
 

media/mojo/clients/mojo_decryptor_unittest.cc

@@ -7,6 +7,8 @@
 #pragma allow_unsafe_buffers
 #endif
 
+#include "media/mojo/clients/mojo_decryptor.h"
+
 #include <stdint.h>
 
 #include <memory>
@@ -20,7 +22,6 @@
 #include "media/base/test_helpers.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
-#include "media/mojo/clients/mojo_decryptor.h"
 #include "media/mojo/mojom/decryptor.mojom.h"
 #include "media/mojo/services/mojo_decryptor_service.h"
 #include "mojo/public/cpp/bindings/receiver.h"
@@ -154,7 +155,7 @@ TEST_F(MojoDecryptorTest, Reset_DuringDecryptAndDecode_Audio) {
     EXPECT_CALL(*this, AudioDecoded(_, _));
   }
 
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(100);
   mojo_decryptor_->DecryptAndDecodeAudio(
       std::move(buffer), base::BindRepeating(&MojoDecryptorTest::AudioDecoded,
                                              base::Unretained(this)));
@@ -177,7 +178,7 @@ TEST_F(MojoDecryptorTest, Reset_DuringDecryptAndDecode_Audio_ChunkedWrite) {
     EXPECT_CALL(*this, AudioDecoded(_, _));
   }
 
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(100);
   mojo_decryptor_->DecryptAndDecodeAudio(
       std::move(buffer), base::BindRepeating(&MojoDecryptorTest::AudioDecoded,
                                              base::Unretained(this)));
@@ -201,7 +202,7 @@ TEST_F(MojoDecryptorTest, Reset_DuringDecryptAndDecode_Video) {
     EXPECT_CALL(*this, OnFrameDestroyed());
   }
 
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(100);
   mojo_decryptor_->DecryptAndDecodeVideo(
       std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
                                              base::Unretained(this)));
@@ -226,7 +227,7 @@ TEST_F(MojoDecryptorTest, Reset_DuringDecryptAndDecode_Video_ChunkedWrite) {
     EXPECT_CALL(*this, OnFrameDestroyed());
   }
 
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(100);
   mojo_decryptor_->DecryptAndDecodeVideo(
       std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
                                              base::Unretained(this)));
@@ -264,7 +265,7 @@ TEST_F(MojoDecryptorTest, Reset_DuringDecryptAndDecode_AudioAndVideo) {
   EXPECT_CALL(*this, VideoDecoded(_, _));
   EXPECT_CALL(*this, OnFrameDestroyed());
 
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(100);
 
   mojo_decryptor_->DecryptAndDecodeAudio(
       buffer, base::BindRepeating(&MojoDecryptorTest::AudioDecoded,
@@ -290,7 +291,7 @@ TEST_F(MojoDecryptorTest, VideoDecodeFreesBuffer) {
   EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
       .WillOnce(Invoke(this, &MojoDecryptorTest::ReturnSharedBufferVideoFrame));
 
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(100);
   mojo_decryptor_->DecryptAndDecodeVideo(
       std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
                                              base::Unretained(this)));
@@ -310,7 +311,7 @@ TEST_F(MojoDecryptorTest, VideoDecodeFreesMultipleBuffers) {
           Invoke(this, &MojoDecryptorTest::ReturnSharedBufferVideoFrame));
 
   for (int i = 0; i < TIMES; ++i) {
-    scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
+    auto buffer = base::MakeRefCounted<DecoderBuffer>(100);
     mojo_decryptor_->DecryptAndDecodeVideo(
         std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
                                                base::Unretained(this)));
@@ -334,7 +335,7 @@ TEST_F(MojoDecryptorTest, VideoDecodeHoldThenFreeBuffers) {
           Invoke(this, &MojoDecryptorTest::ReturnSharedBufferVideoFrame));
 
   for (int i = 0; i < 2; ++i) {
-    scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
+    auto buffer = base::MakeRefCounted<DecoderBuffer>(100);
     mojo_decryptor_->DecryptAndDecodeVideo(
         std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
                                                base::Unretained(this)));
@@ -361,7 +362,7 @@ TEST_F(MojoDecryptorTest, EOSBuffer) {
   EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
       .WillOnce(Invoke(this, &MojoDecryptorTest::ReturnEOSVideoFrame));
 
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(100);
   mojo_decryptor_->DecryptAndDecodeVideo(
       std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
                                              base::Unretained(this)));
@@ -383,7 +384,7 @@ TEST_F(MojoDecryptorTest, DestroyService) {
   EXPECT_CALL(*this, VideoDecoded(Decryptor::Status::kError, IsNull()));
   EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _)).Times(0);
 
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(100));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(100);
   mojo_decryptor_->DecryptAndDecodeVideo(
       std::move(buffer), base::BindRepeating(&MojoDecryptorTest::VideoDecoded,
                                              base::Unretained(this)));

media/mojo/common/mojo_decoder_buffer_converter_unittest.cc

@@ -8,6 +8,7 @@
 
 #include <memory>
 
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
 #include "base/test/mock_callback.h"
 #include "base/test/task_environment.h"
@@ -89,7 +90,7 @@ TEST(MojoDecoderBufferConverterTest, ConvertDecoderBuffer_EOS) {
 // See http://crbug.com/663438
 TEST(MojoDecoderBufferConverterTest, ConvertDecoderBuffer_ZeroByteBuffer) {
   base::test::SingleThreadTaskEnvironment task_environment;
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(0));
+  auto buffer = base::MakeRefCounted<DecoderBuffer>(0);
 
   MojoDecoderBufferConverter converter;
   converter.ConvertAndVerify(buffer);

media/mojo/services/cdm_service_unittest.cc

@@ -10,6 +10,7 @@
 #include "base/files/file_path.h"
 #include "base/functional/bind.h"
 #include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
 #include "base/test/task_environment.h"
 #include "base/unguessable_token.h"
@@ -150,7 +151,7 @@ class CdmServiceTest : public testing::Test {
 
   // MojoCdmService will always create/use `mock_cdm_factory_` and `mock_cdm_`,
   // so it's easier to set expectations on them.
-  scoped_refptr<MockCdm> mock_cdm_{new MockCdm()};
+  scoped_refptr<MockCdm> mock_cdm_ = base::MakeRefCounted<MockCdm>();
   MockCdmFactory mock_cdm_factory_{mock_cdm_};
   NiceMock<MockCdmContext> cdm_context_;
 

media/remoting/stream_provider_unittest.cc

@@ -5,6 +5,7 @@
 #include "media/remoting/stream_provider.h"
 
 #include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/test/task_environment.h"
 #include "media/base/audio_decoder_config.h"
@@ -33,7 +34,7 @@ class StreamProviderTest : public testing::Test {
   StreamProviderTest()
       : audio_config_(TestAudioConfig::Normal()),
         video_config_(TestVideoConfig::Normal()),
-        audio_buffer_(new DecoderBuffer(kBufferSize)),
+        audio_buffer_(base::MakeRefCounted<DecoderBuffer>(kBufferSize)),
         video_buffer_(DecoderBuffer::CreateEOSBuffer()) {}
 
   void SetUp() override {

media/renderers/audio_renderer_impl.cc

@@ -44,14 +44,14 @@ namespace media {
 
 AudioRendererImpl::AudioRendererImpl(
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
-    AudioRendererSink* sink,
+    scoped_refptr<AudioRendererSink> sink,
     const CreateAudioDecodersCB& create_audio_decoders_cb,
     MediaLog* media_log,
     MediaPlayerLoggingID media_player_id,
     SpeechRecognitionClient* speech_recognition_client)
     : task_runner_(task_runner),
       expecting_config_changes_(false),
-      sink_(sink),
+      sink_(std::move(sink)),
       media_log_(media_log),
       player_id_(media_player_id),
       client_(nullptr),
@@ -430,11 +430,11 @@ void AudioRendererImpl::OnDeviceInfoReceived(
     MEDIA_LOG(ERROR, media_log_)
         << "Output device error, falling back to null sink. device_status="
         << output_device_info.device_status();
-    sink_ = new NullAudioSink(task_runner_);
+    sink_ = base::MakeRefCounted<NullAudioSink>(task_runner_);
     output_device_info = sink_->GetOutputDeviceInfo();
   } else if (base::FeatureList::IsEnabled(kSuspendMutedAudio)) {
     // If playback is muted, we use a fake sink for output until it unmutes.
-    null_sink_ = new NullAudioSink(task_runner_);
+    null_sink_ = base::MakeRefCounted<NullAudioSink>(task_runner_);
   }
 
   current_decoder_config_ = stream->audio_decoder_config();

media/renderers/audio_renderer_impl.h

@@ -76,7 +76,7 @@ class MEDIA_EXPORT AudioRendererImpl
   // |decoders| contains the AudioDecoders to use when initializing.
   AudioRendererImpl(
       const scoped_refptr<base::SequencedTaskRunner>& task_runner,
-      AudioRendererSink* sink,
+      scoped_refptr<AudioRendererSink> sink,
       const CreateAudioDecodersCB& create_audio_decoders_cb,
       MediaLog* media_log,
       MediaPlayerLoggingID media_player_id,

media/renderers/audio_renderer_impl_unittest.cc

@@ -128,7 +128,7 @@ class AudioRendererImplTest : public ::testing::Test,
                          512),
         main_thread_task_runner_(
             base::SingleThreadTaskRunner::GetCurrentDefault()),
-        sink_(new FakeAudioRendererSink(hardware_params_)),
+        sink_(base::MakeRefCounted<FakeAudioRendererSink>(hardware_params_)),
         demuxer_stream_(DemuxerStream::AUDIO),
         expected_init_result_(true),
         enter_pending_decoder_init_(false),
@@ -145,7 +145,7 @@ class AudioRendererImplTest : public ::testing::Test,
         ChannelLayoutConfig::FromLayout<kChannelLayout>(),
         kOutputSamplesPerSecond, 512);
     renderer_ = std::make_unique<AudioRendererImpl>(
-        main_thread_task_runner_, sink_.get(),
+        main_thread_task_runner_, sink_,
         base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
                             base::Unretained(this)),
         &media_log_, 0, this);
@@ -174,7 +174,7 @@ class AudioRendererImplTest : public ::testing::Test,
       stalled_demixer_read_cb_ = std::move(read_cb);
       return;
     }
-    scoped_refptr<DecoderBuffer> decoder_buffer(new DecoderBuffer(0));
+    auto decoder_buffer = base::MakeRefCounted<DecoderBuffer>(0);
     std::move(read_cb).Run(DemuxerStream::kOk, {std::move(decoder_buffer)});
   }
 
@@ -190,7 +190,7 @@ class AudioRendererImplTest : public ::testing::Test,
     hardware_params_ = params;
     sink_ = base::MakeRefCounted<FakeAudioRendererSink>(hardware_params_);
     renderer_ = std::make_unique<AudioRendererImpl>(
-        main_thread_task_runner_, sink_.get(),
+        main_thread_task_runner_, sink_,
         base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
                             base::Unretained(this)),
         &media_log_, 0, nullptr);
@@ -204,7 +204,7 @@ class AudioRendererImplTest : public ::testing::Test,
     hardware_params_ = hardware_params;
     sink_ = base::MakeRefCounted<FakeAudioRendererSink>(hardware_params_);
     renderer_ = std::make_unique<AudioRendererImpl>(
-        main_thread_task_runner_, sink_.get(),
+        main_thread_task_runner_, sink_,
         base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
                             base::Unretained(this)),
         &media_log_, 0, nullptr);
@@ -215,7 +215,7 @@ class AudioRendererImplTest : public ::testing::Test,
   void ConfigureWithMockSink(const AudioParameters& params) {
     mock_sink_ = base::MakeRefCounted<MockAudioRendererSink>();
     renderer_ = std::make_unique<AudioRendererImpl>(
-        main_thread_task_runner_, mock_sink_.get(),
+        main_thread_task_runner_, mock_sink_,
         base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
                             base::Unretained(this)),
         &media_log_, 0, nullptr);
@@ -226,7 +226,7 @@ class AudioRendererImplTest : public ::testing::Test,
   void ConfigureWithMockMediaLog() {
     sink_ = base::MakeRefCounted<FakeAudioRendererSink>(hardware_params_);
     renderer_ = std::make_unique<AudioRendererImpl>(
-        main_thread_task_runner_, sink_.get(),
+        main_thread_task_runner_, sink_,
         base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
                             base::Unretained(this)),
         &mock_media_log_, 0, nullptr);
@@ -301,7 +301,7 @@ class AudioRendererImplTest : public ::testing::Test,
     ConfigureDemuxerStream(true);
 
     renderer_ = std::make_unique<AudioRendererImpl>(
-        main_thread_task_runner_, sink_.get(),
+        main_thread_task_runner_, sink_,
         base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
                             base::Unretained(this)),
         &media_log_, 0, this);
@@ -1526,7 +1526,7 @@ TEST_F(AudioRendererImplTest, MutedPlaybackBadDeviceInfo) {
       std::string(), OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED,
       AudioParameters());
   renderer_ = std::make_unique<AudioRendererImpl>(
-      main_thread_task_runner_, mock_sink_.get(),
+      main_thread_task_runner_, mock_sink_,
       base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
                           base::Unretained(this)),
       &media_log_, 0, nullptr);

media/renderers/paint_canvas_video_renderer.cc

@@ -23,6 +23,7 @@
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/numerics/checked_math.h"
 #include "base/sequence_checker.h"
 #include "base/synchronization/waitable_event.h"
@@ -1257,8 +1258,8 @@ bool TexImageHelper(VideoFrame* frame,
 
   size_t output_row_bytes =
       frame->visible_rect().width() * output_bytes_per_pixel;
-  *temp_buffer =
-      new DataBuffer(output_row_bytes * frame->visible_rect().height());
+  *temp_buffer = base::MakeRefCounted<DataBuffer>(
+      output_row_bytes * frame->visible_rect().height());
   FlipAndConvertY16(frame, (*temp_buffer)->writable_data().data(), format, type,
                     flip_y, output_row_bytes);
   return true;

media/renderers/video_renderer_impl_unittest.cc

@@ -16,6 +16,7 @@
 #include "base/functional/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/notreached.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ -186,7 +187,7 @@ class VideoRendererImplTest : public testing::Test {
       }
     }
 
-    scoped_refptr<DecoderBuffer> decoder_buffer(new DecoderBuffer(0));
+    auto decoder_buffer = base::MakeRefCounted<DecoderBuffer>(0);
 
     // Set |decoder_buffer| timestamp such that it won't match any of the
     // times provided to QueueFrames(). Otherwise the default timestamp of 0 may

media/test/fake_encrypted_media.cc

@@ -5,6 +5,7 @@
 #include "media/test/fake_encrypted_media.h"
 
 #include "base/functional/bind.h"
+#include "base/memory/scoped_refptr.h"
 #include "media/base/cdm_key_information.h"
 #include "media/cdm/aes_decryptor.h"
 
@@ -18,7 +19,7 @@ Decryptor* FakeEncryptedMedia::TestCdmContext::GetDecryptor() {
 }
 
 FakeEncryptedMedia::FakeEncryptedMedia(AppBase* app)
-    : decryptor_(new AesDecryptor(
+    : decryptor_(base::MakeRefCounted<AesDecryptor>(
           base::BindRepeating(&FakeEncryptedMedia::OnSessionMessage,
                               base::Unretained(this)),
           base::BindRepeating(&FakeEncryptedMedia::OnSessionClosed,

media/test/pipeline_integration_test_base.cc

@@ -11,6 +11,7 @@
 #include "base/functional/bind.h"
 #include "base/functional/callback.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/threading/sequence_bound.h"
@@ -594,14 +595,14 @@ std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRendererImpl(
   if (!clockless_playback_) {
     DCHECK(!mono_output_) << " NullAudioSink doesn't specify output parameters";
 
-    audio_sink_ =
-        new NullAudioSink(task_environment_.GetMainThreadTaskRunner());
+    audio_sink_ = base::MakeRefCounted<NullAudioSink>(
+        task_environment_.GetMainThreadTaskRunner());
   } else {
     ChannelLayoutConfig output_layout_config =
         mono_output_ ? ChannelLayoutConfig::Mono()
                      : ChannelLayoutConfig::Stereo();
 
-    clockless_audio_sink_ = new ClocklessAudioSink(
+    clockless_audio_sink_ = base::MakeRefCounted<ClocklessAudioSink>(
         OutputDeviceInfo("", OUTPUT_DEVICE_STATUS_OK,
                          AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                          output_layout_config, 44100, 512)));

third_party/blink/public/platform/web_audio_source_provider_impl.h

@@ -95,10 +95,9 @@ class BLINK_PLATFORM_EXPORT WebAudioSourceProviderImpl
 
   bool IsAudioBeingCaptured() const;
 
- protected:
+ private:
   ~WebAudioSourceProviderImpl() override;
 
- private:
   friend class WebAudioSourceProviderImplTest;
 
   // Calls setFormat() on |client_| from the Blink renderer thread.

third_party/blink/renderer/core/exported/web_media_player_impl_unittest.cc

@@ -444,7 +444,7 @@ class WebMediaPlayerImplTest
                          media::mojom::MediaStreamType::kNone);
 
     audio_sink_ =
-        base::WrapRefCounted(new NiceMock<media::MockAudioRendererSink>());
+        base::MakeRefCounted<NiceMock<media::MockAudioRendererSink>>();
 
     url_index_ = std::make_unique<UrlIndex>(&mock_resource_fetch_context_,
                                             media_thread_.task_runner());

third_party/blink/renderer/modules/media/audio/audio_renderer_mixer_input.h

@@ -79,10 +79,9 @@ class BLINK_MODULES_EXPORT AudioRendererMixerInput
   // Called by AudioRendererMixer when an error occurs.
   void OnRenderError();
 
- protected:
+ private:
   ~AudioRendererMixerInput() override;
 
- private:
   friend class AudioRendererMixerInputTest;
 
   // Pool to obtain mixers from / return them to.

third_party/blink/renderer/modules/media/audio/audio_renderer_mixer_manager_test.cc

@@ -770,7 +770,7 @@ TEST_F(AudioRendererMixerManagerTest, MixerParamsLatencyPlayback) {
 // latency when the device buffer size exceeds 20 ms.
 TEST_F(AudioRendererMixerManagerTest,
        MixerParamsLatencyPlaybackLargeDeviceBufferSize) {
-  mock_sink_ = new media::MockAudioRendererSink(
+  mock_sink_ = base::MakeRefCounted<media::MockAudioRendererSink>(
       std::string(), media::OUTPUT_DEVICE_STATUS_OK,
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR,
                       media::ChannelLayoutConfig::FromLayout<kChannelLayout>(),
@@ -810,7 +810,7 @@ TEST_F(AudioRendererMixerManagerTest,
 // Verify output bufer size of the mixer is correctly adjusted for Playback
 // latency when output audio is fake.
 TEST_F(AudioRendererMixerManagerTest, MixerParamsLatencyPlaybackFakeAudio) {
-  mock_sink_ = new media::MockAudioRendererSink(
+  mock_sink_ = base::MakeRefCounted<media::MockAudioRendererSink>(
       std::string(), media::OUTPUT_DEVICE_STATUS_OK,
       AudioParameters(AudioParameters::AUDIO_FAKE,
                       media::ChannelLayoutConfig::FromLayout<kChannelLayout>(),
@@ -892,7 +892,7 @@ TEST_F(AudioRendererMixerManagerTest, MixerParamsLatencyRtc) {
 // Verify output bufer size of the mixer is correctly adjusted for RTC latency
 // when output audio is fake.
 TEST_F(AudioRendererMixerManagerTest, MixerParamsLatencyRtcFakeAudio) {
-  mock_sink_ = new media::MockAudioRendererSink(
+  mock_sink_ = base::MakeRefCounted<media::MockAudioRendererSink>(
       std::string(), media::OUTPUT_DEVICE_STATUS_OK,
       AudioParameters(AudioParameters::AUDIO_FAKE,
                       media::ChannelLayoutConfig::FromLayout<kChannelLayout>(),
@@ -956,7 +956,7 @@ TEST_F(AudioRendererMixerManagerTest, MixerParamsLatencyInteractive) {
 // Verify output parameters are the same as input properties for bitstream
 // formats.
 TEST_F(AudioRendererMixerManagerTest, MixerParamsBitstreamFormat) {
-  mock_sink_ = new media::MockAudioRendererSink(
+  mock_sink_ = base::MakeRefCounted<media::MockAudioRendererSink>(
       std::string(), media::OUTPUT_DEVICE_STATUS_OK,
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR,
                       media::ChannelLayoutConfig::FromLayout<kChannelLayout>(),

third_party/blink/renderer/modules/media/audio/audio_renderer_sink_cache_test.cc

@@ -9,6 +9,7 @@
 #include "base/check.h"
 #include "base/functional/bind.h"
 #include "base/functional/callback_helpers.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread.h"
 #include "media/audio/audio_device_description.h"
@@ -61,7 +62,8 @@ class AudioRendererSinkCacheTest : public testing::Test {
   scoped_refptr<media::AudioRendererSink> CreateSink(
       const LocalFrameToken& frame_token,
       const std::string& device_id) {
-    return new testing::NiceMock<media::MockAudioRendererSink>(
+    return base::MakeRefCounted<
+        testing::NiceMock<media::MockAudioRendererSink>>(
         device_id, (device_id == kUnhealthyDeviceId)
                        ? media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL
                        : media::OUTPUT_DEVICE_STATUS_OK);
@@ -149,7 +151,7 @@ TEST_F(AudioRendererSinkCacheTest, UnhealthySinkIsNotCached) {
 // unhealthy.
 TEST_F(AudioRendererSinkCacheTest, UnhealthySinkIsStopped) {
   scoped_refptr<media::MockAudioRendererSink> sink =
-      new media::MockAudioRendererSink(
+      base::MakeRefCounted<media::MockAudioRendererSink>(
           kUnhealthyDeviceId, media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL);
 
   cache_.reset();  // Destruct first so there's only one cache at a time.

third_party/blink/renderer/modules/mediacapturefromelement/html_audio_element_capturer_source_unittest.cc

@@ -4,6 +4,7 @@
 
 #include "third_party/blink/renderer/modules/mediacapturefromelement/html_audio_element_capturer_source.h"
 
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
@@ -48,9 +49,9 @@ class HTMLAudioElementCapturerSourceTest : public testing::Test {
  public:
   HTMLAudioElementCapturerSourceTest()
       : fake_callback_(0.1, kAudioTrackSampleRate),
-        audio_source_(new blink::WebAudioSourceProviderImpl(
-            new media::NullAudioSink(
-                blink::scheduler::GetSingleThreadTaskRunnerForTesting()),
+        audio_source_(base::MakeRefCounted<WebAudioSourceProviderImpl>(
+            base::MakeRefCounted<media::NullAudioSink>(
+                scheduler::GetSingleThreadTaskRunnerForTesting()),
             &media_log_)) {}
 
   void SetUp() final {

third_party/blink/renderer/modules/mediastream/testing_platform_support_with_mock_audio_capture_source.h

@@ -29,7 +29,7 @@ class MockAudioCapturerSource : public media::AudioCapturerSource {
   void SetVolume(double volume) override {}
   void SetOutputDeviceForAec(const std::string& output_device_id) override {}
 
- protected:
+ private:
   ~MockAudioCapturerSource() override = default;
 };
 

third_party/blink/renderer/modules/peerconnection/webrtc_audio_renderer_test.cc

@@ -102,7 +102,7 @@ class AudioDeviceFactoryTestingPlatformSupport : public blink::Platform {
       const media::AudioSinkParameters& params) override {
     MockNewAudioRendererSink(source_type, web_frame, params);
 
-    mock_sink_ = new media::MockAudioRendererSink(
+    mock_sink_ = base::MakeRefCounted<media::MockAudioRendererSink>(
         params.device_id,
         params.device_id == kInvalidOutputDeviceId
             ? media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL