Makes AudioOutputDispatcher non-ref-counted.

media/audio/audio_output_proxy_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_output_resampler.h"
@@ skipping 147 matching lines @@
     InitDispatcher(base::TimeDelta::FromMilliseconds(kTestCloseDelayMs));
   }
 
   void TearDown() override {
     // This is necessary to free all proxy objects that have been
     // closed by the test.
     base::RunLoop().RunUntilIdle();
   }
 
   virtual void InitDispatcher(base::TimeDelta close_delay) {
-    dispatcher_impl_ = new AudioOutputDispatcherImpl(&manager(),
-                                                     params_,
-                                                     std::string(),
-                                                     close_delay);
+    dispatcher_impl_ = base::MakeUnique<AudioOutputDispatcherImpl>(
+        &manager(), params_, std::string(), close_delay);
   }
 
   virtual void OnStart() {}
 
   MockAudioManager& manager() {
     return manager_;
   }
 
   void WaitForCloseTimer(MockAudioOutputStream* stream) {
     base::RunLoop run_loop;
@@ skipping 224 matching lines @@
     // callback may not have had time to process the OnError() in between.
     proxy->Stop();
     proxy->Start(&callback_);
 
     Mock::VerifyAndClear(&callback_);
 
     proxy->Close();
   }
 
   base::MessageLoop message_loop_;
-  scoped_refptr<AudioOutputDispatcherImpl> dispatcher_impl_;
+  std::unique_ptr<AudioOutputDispatcherImpl> dispatcher_impl_;
   MockAudioManager manager_;
   MockAudioSourceCallback callback_;
   AudioParameters params_;
 };
 
 class AudioOutputResamplerTest : public AudioOutputProxyTest {
  public:
   void TearDown() override { AudioOutputProxyTest::TearDown(); }
 
   void InitDispatcher(base::TimeDelta close_delay) override {
     // Use a low sample rate and large buffer size when testing otherwise the
     // FakeAudioOutputStream will keep the message loop busy indefinitely; i.e.,
     // RunUntilIdle() will never terminate.
     resampler_params_ = AudioParameters(
         AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
         16000, 16, 1024);
-    resampler_ = new AudioOutputResampler(
+    resampler_ = base::MakeUnique<AudioOutputResampler>(
         &manager(), params_, resampler_params_, std::string(), close_delay);
   }
 
   void OnStart() override {
     // Let Start() run for a bit.
     base::RunLoop run_loop;
     message_loop_.task_runner()->PostDelayedTask(
         FROM_HERE, run_loop.QuitClosure(),
         base::TimeDelta::FromMilliseconds(kStartRunTimeMs));
     run_loop.Run();
   }
 
  protected:
   AudioParameters resampler_params_;
-  scoped_refptr<AudioOutputResampler> resampler_;
+  std::unique_ptr<AudioOutputResampler> resampler_;
 };
 
 TEST_F(AudioOutputProxyTest, CreateAndClose) {
   AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher_impl_.get());
   proxy->Close();
 }
 
 TEST_F(AudioOutputResamplerTest, CreateAndClose) {
   AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
   proxy->Close();
@@ skipping 274 matching lines @@
       .WillOnce(Return(&real_stream));
 
   // Stream1 should be able to successfully open and start.
   EXPECT_CALL(real_stream, Open()).WillOnce(Return(true));
   proxy = new AudioOutputProxy(resampler_.get());
   EXPECT_TRUE(proxy->Open());
   CloseAndWaitForCloseTimer(proxy, &real_stream);
 }
 
 }  // namespace media