Factor out AudioOutputDelegate from AudioRendererHost.

content/browser/renderer_host/media/audio_renderer_host_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 "content/browser/renderer_host/media/audio_renderer_host.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 83 matching lines @@
     set_render_frame_id_validate_function_for_testing(&ValidateRenderFrameId);
   }
 
   // A list of mock methods.
   MOCK_METHOD0(ShutdownForBadMessage, void());
   MOCK_METHOD4(OnDeviceAuthorized,
                void(int stream_id,
                     media::OutputDeviceStatus device_status,
                     const media::AudioParameters& output_params,
                     const std::string& matched_device_id));
-  MOCK_METHOD2(OnStreamCreated, void(int stream_id, int length));
-  MOCK_METHOD1(OnStreamError, void(int stream_id));
+  MOCK_METHOD2(WasNotifiedOfCreation, void(int stream_id, int length));
+  MOCK_METHOD1(WasNotifiedOfError, void(int stream_id));
 
  private:
   virtual ~MockAudioRendererHost() {
     // Make sure all audio streams have been deleted.
-    EXPECT_TRUE(audio_entries_.empty());
+    EXPECT_TRUE(delegates_.empty());
   }
 
   // This method is used to dispatch IPC messages to the renderer. We intercept
   // these messages here and dispatch to our mock methods to verify the
   // conversation between this object and the renderer.
   // Note: this means that file descriptors won't be duplicated,
   // leading to double-close errors from SyncSocket.
   // See crbug.com/647659.
   virtual bool Send(IPC::Message* message) {
     CHECK(message);
@@ skipping 34 matching lines @@
     CHECK(shared_memory_->Map(length));
     CHECK(shared_memory_->memory());
     shared_memory_length_ = length;
 
     // Create the SyncSocket using the handle.
     base::SyncSocket::Handle sync_socket_handle =
         base::SyncSocket::UnwrapHandle(socket_descriptor);
     sync_socket_.reset(new base::SyncSocket(sync_socket_handle));
 
     // And then delegate the call to the mock method.
-    OnStreamCreated(stream_id, length);
+    WasNotifiedOfCreation(stream_id, length);
   }
 
-  void OnNotifyStreamError(int stream_id) { OnStreamError(stream_id); }
+  void OnNotifyStreamError(int stream_id) { WasNotifiedOfError(stream_id); }
 
   std::unique_ptr<base::SharedMemory> shared_memory_;
   std::unique_ptr<base::SyncSocket> sync_socket_;
   uint32_t shared_memory_length_;
   base::RunLoop* auth_run_loop_;  // Used to wait for authorization.
 
   DISALLOW_COPY_AND_ASSIGN(MockAudioRendererHost);
 };
 
 class AudioRendererHostTest : public testing::Test {
@@ skipping 39 matching lines @@
         device_id == kDefaultDeviceId
             ? media::OUTPUT_DEVICE_STATUS_OK
             : device_id == kBadDeviceId
                   ? media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED
                   : media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND;
 
     EXPECT_CALL(*host_.get(),
                 OnDeviceAuthorized(kStreamId, expected_device_status, _, _));
 
     if (expected_device_status == media::OUTPUT_DEVICE_STATUS_OK) {
-      EXPECT_CALL(*host_.get(), OnStreamCreated(kStreamId, _));
+      EXPECT_CALL(*host_.get(), WasNotifiedOfCreation(kStreamId, _));
       EXPECT_CALL(mirroring_manager_,
                   AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()))
           .RetiresOnSaturation();
     }
 
     // Send a create stream message to the audio output stream and wait until
     // we receive the created message.
     media::AudioParameters params(
         media::AudioParameters::AUDIO_FAKE, media::CHANNEL_LAYOUT_STEREO,
         media::AudioParameters::kAudioCDSampleRate, 16,
@@ skipping 29 matching lines @@
     SyncWithAudioThread();
   }
 
   void CreateWithoutWaitingForAuth(const std::string& device_id) {
     Create(false, device_id, url::Origin(GURL(kSecurityOrigin)), false);
   }
 
   void CreateWithInvalidRenderFrameId() {
     // When creating a stream with an invalid render frame ID, the host will
     // reply with a stream error message.
-    EXPECT_CALL(*host_, OnStreamError(kStreamId));
+    EXPECT_CALL(*host_, WasNotifiedOfError(kStreamId));
 
     // However, validation does not block stream creation, so these method calls
     // might be made:
-    EXPECT_CALL(*host_, OnStreamCreated(kStreamId, _)).Times(AtLeast(0));
+    EXPECT_CALL(*host_, WasNotifiedOfCreation(kStreamId, _)).Times(AtLeast(0));
     EXPECT_CALL(mirroring_manager_, AddDiverter(_, _, _)).Times(AtLeast(0));
     EXPECT_CALL(mirroring_manager_, RemoveDiverter(_)).Times(AtLeast(0));
 
     // Provide a seemingly-valid render frame ID; and it should be rejected when
     // AudioRendererHost calls ValidateRenderFrameId().
     const int kInvalidRenderFrameId = kRenderFrameId + 1;
     const media::AudioParameters params(
         media::AudioParameters::AUDIO_FAKE, media::CHANNEL_LAYOUT_STEREO,
         media::AudioParameters::kAudioCDSampleRate, 16,
         media::AudioParameters::kAudioCDSampleRate / 10);
@@ skipping 17 matching lines @@
     host_->OnPauseStream(kStreamId);
     SyncWithAudioThread();
   }
 
   void SetVolume(double volume) {
     host_->OnSetVolume(kStreamId, volume);
     SyncWithAudioThread();
   }
 
   void SimulateError() {
-    EXPECT_EQ(1u, host_->audio_entries_.size())
+    EXPECT_EQ(1u, host_->delegates_.size())
         << "Calls Create() before calling this method";
 
     // Expect an error signal sent through IPC.
-    EXPECT_CALL(*host_.get(), OnStreamError(kStreamId));
+    EXPECT_CALL(*host_.get(), WasNotifiedOfError(kStreamId));
 
     // Simulate an error sent from the audio device.
-    host_->ReportErrorAndClose(kStreamId);
+    host_->OnStreamError(kStreamId);
     SyncWithAudioThread();
 
     // Expect the audio stream record is removed.
-    EXPECT_EQ(0u, host_->audio_entries_.size());
+    EXPECT_EQ(0u, host_->delegates_.size());
   }
 
   // SyncWithAudioThread() waits until all pending tasks on the audio thread
   // are executed while also processing pending task in message_loop_ on the
   // current thread. It is used to synchronize with the audio thread when we are
   // closing an audio stream.
   void SyncWithAudioThread() {
     base::RunLoop().RunUntilIdle();
 
     base::RunLoop run_loop;
@@ skipping 107 matching lines @@
 }
 
 TEST_F(AudioRendererHostTest, CreateFailsForInvalidRenderFrame) {
   CreateWithInvalidRenderFrameId();
   Close();
 }
 
 // TODO(hclam): Add tests for data conversation in low latency mode.
 
 }  // namespace content