Factor out AudioOutputDelegate from AudioRendererHost.

media/audio/audio_output_controller_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 "media/audio/audio_output_controller.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
@@ skipping 30 matching lines @@
 static const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
 static const int kSamplesPerPacket = kSampleRate / 100;
 static const double kTestVolume = 0.25;
 static const float kBufferNonZeroData = 1.0f;
 
 class MockAudioOutputControllerEventHandler
     : public AudioOutputController::EventHandler {
  public:
   MockAudioOutputControllerEventHandler() {}
 
-  MOCK_METHOD0(OnCreated, void());
-  MOCK_METHOD0(OnPlaying, void());
-  MOCK_METHOD0(OnPaused, void());
-  MOCK_METHOD0(OnError, void());
+  MOCK_METHOD0(OnControllerCreated, void());
+  MOCK_METHOD0(OnControllerPlaying, void());
+  MOCK_METHOD0(OnControllerPaused, void());
+  MOCK_METHOD0(OnControllerError, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAudioOutputControllerEventHandler);
 };
 
 class MockAudioOutputControllerSyncReader
     : public AudioOutputController::SyncReader {
  public:
   MockAudioOutputControllerSyncReader() {}
 
@@ skipping 53 matching lines @@
 
   ~AudioOutputControllerTest() override {}
 
  protected:
   void Create(int samples_per_packet) {
     params_ = AudioParameters(
         AudioParameters::AUDIO_FAKE, kChannelLayout,
         kSampleRate, kBitsPerSample, samples_per_packet);
 
     if (params_.IsValid()) {
-      EXPECT_CALL(mock_event_handler_, OnCreated());
+      EXPECT_CALL(mock_event_handler_, OnControllerCreated());
     }
 
     controller_ = AudioOutputController::Create(
         audio_manager_.get(), &mock_event_handler_, params_, std::string(),
         &mock_sync_reader_);
     if (controller_.get())
       controller_->SetVolume(kTestVolume);
 
     EXPECT_EQ(params_.IsValid(), controller_.get() != NULL);
     base::RunLoop().RunUntilIdle();
   }
 
   void Play() {
-    // Expect the event handler to receive one OnPlaying() call.
-    EXPECT_CALL(mock_event_handler_, OnPlaying());
+    // Expect the event handler to receive one OnControllerPlaying() call.
+    EXPECT_CALL(mock_event_handler_, OnControllerPlaying());
 
     // During playback, the mock pretends to provide audio data rendered and
     // sent from the render process.
     EXPECT_CALL(mock_sync_reader_, RequestMoreData(_, _, _)).Times(AtLeast(1));
     EXPECT_CALL(mock_sync_reader_, Read(_)).WillRepeatedly(PopulateBuffer());
     controller_->Play();
     base::RunLoop().RunUntilIdle();
   }
 
   void Pause() {
-    // Expect the event handler to receive one OnPaused() call.
-    EXPECT_CALL(mock_event_handler_, OnPaused());
+    // Expect the event handler to receive one OnControllerPaused() call.
+    EXPECT_CALL(mock_event_handler_, OnControllerPaused());
 
     controller_->Pause();
     base::RunLoop().RunUntilIdle();
   }
 
   void ChangeDevice() {
-    // Expect the event handler to receive one OnPaying() call and no OnPaused()
-    // call.
-    EXPECT_CALL(mock_event_handler_, OnPlaying());
-    EXPECT_CALL(mock_event_handler_, OnPaused())
-        .Times(0);
+    // Expect the event handler to receive one OnControllerPaying() call and no
+    // OnControllerPaused() call.
+    EXPECT_CALL(mock_event_handler_, OnControllerPlaying());
+    EXPECT_CALL(mock_event_handler_, OnControllerPaused()).Times(0);
 
     // Simulate a device change event to AudioOutputController from the
     // AudioManager.
     audio_manager_->GetTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&AudioOutputController::OnDeviceChange, controller_));
   }
 
   void Divert(bool was_playing, int num_times_to_be_started) {
     if (was_playing) {
-      // Expect the handler to receive one OnPlaying() call as a result of the
-      // stream switching.
-      EXPECT_CALL(mock_event_handler_, OnPlaying());
+      // Expect the handler to receive one OnControllerPlaying() call as a
+      // result of the stream switching.
+      EXPECT_CALL(mock_event_handler_, OnControllerPlaying());
     }
 
     EXPECT_CALL(mock_stream_, Open())
         .WillOnce(Return(true));
     EXPECT_CALL(mock_stream_, SetVolume(kTestVolume));
     if (num_times_to_be_started > 0) {
       EXPECT_CALL(mock_stream_, Start(NotNull()))
           .Times(num_times_to_be_started)
           .WillRepeatedly(
               Invoke(&mock_stream_, &MockAudioOutputStream::SetCallback));
@@ skipping 31 matching lines @@
         base::TimeDelta(), base::TimeTicks::Now(), 0, dest.get());
 
     EXPECT_LT(0, frames_read);
     EXPECT_EQ(kBufferNonZeroData, dest->channel(0)[0]);
 
     base::RunLoop().RunUntilIdle();
   }
 
   void Revert(bool was_playing) {
     if (was_playing) {
-      // Expect the handler to receive one OnPlaying() call as a result of the
-      // stream switching back.
-      EXPECT_CALL(mock_event_handler_, OnPlaying());
+      // Expect the handler to receive one OnControllerPlaying() call as a
+      // result of the stream switching back.
+      EXPECT_CALL(mock_event_handler_, OnControllerPlaying());
     }
 
     EXPECT_CALL(mock_stream_, Close());
 
     controller_->StopDiverting();
     base::RunLoop().RunUntilIdle();
   }
 
   void StopDuplicating(MockAudioPushSink* sink) {
     EXPECT_CALL(*sink, Close());
     controller_->StopDuplicating(sink);
     base::RunLoop().RunUntilIdle();
   }
 
   void SwitchDevice(bool diverting) {
     if (!diverting) {
       // Expect the current stream to close and a new stream to start
       // playing if not diverting. When diverting, nothing happens
       // until diverting is stopped.
-      EXPECT_CALL(mock_event_handler_, OnPlaying());
+      EXPECT_CALL(mock_event_handler_, OnControllerPlaying());
     }
 
     controller_->SwitchOutputDevice(
         AudioDeviceDescription::GetDefaultDeviceName(),
         base::Bind(&base::DoNothing));
     base::RunLoop().RunUntilIdle();
   }
 
   void Close() {
     EXPECT_CALL(mock_sync_reader_, Close());
@@ skipping 167 matching lines @@
   // Switching device would trigger a read, and in turn it would trigger a push
   // to sink.
   EXPECT_CALL(mock_sink, OnDataCheck(kBufferNonZeroData));
   SwitchDevice(false);
 
   StopDuplicating(&mock_sink);
   Close();
 }
 
 }  // namespace media