OLD | NEW |
| (Empty) |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "base/process_util.h" | |
6 #include "chrome/common/render_messages.h" | |
7 #include "chrome/common/render_messages_params.h" | |
8 #include "chrome/renderer/media/audio_renderer_impl.h" | |
9 #include "media/base/data_buffer.h" | |
10 #include "media/base/media_format.h" | |
11 #include "media/base/mock_callback.h" | |
12 #include "media/base/mock_filter_host.h" | |
13 #include "media/base/mock_filters.h" | |
14 #include "testing/gtest/include/gtest/gtest.h" | |
15 | |
16 using ::testing::ReturnRef; | |
17 | |
18 class AudioRendererImplTest : public ::testing::Test { | |
19 public: | |
20 static const int kRouteId = 0; | |
21 static const int kSize = 1024; | |
22 | |
23 AudioRendererImplTest() { | |
24 message_loop_.reset(new MessageLoop(MessageLoop::TYPE_IO)); | |
25 | |
26 // TODO(scherkus): use gmock with AudioMessageFilter to verify | |
27 // AudioRendererImpl calls or doesn't call Send(). | |
28 filter_ = new AudioMessageFilter(kRouteId); | |
29 filter_->message_loop_ = message_loop_.get(); | |
30 | |
31 // Create temporary shared memory. | |
32 CHECK(shared_mem_.CreateAnonymous(kSize)); | |
33 | |
34 // Setup expectations for initialization. | |
35 decoder_ = new media::MockAudioDecoder(); | |
36 | |
37 // Associate media format with decoder | |
38 decoder_media_format_.SetAsInteger(media::MediaFormat::kChannels, 2); | |
39 decoder_media_format_.SetAsInteger(media::MediaFormat::kSampleRate, 48000); | |
40 decoder_media_format_.SetAsInteger(media::MediaFormat::kSampleBits, 16); | |
41 EXPECT_CALL(*decoder_, media_format()) | |
42 .WillRepeatedly(ReturnRef(decoder_media_format_)); | |
43 | |
44 // Create and initialize audio renderer. | |
45 renderer_ = new AudioRendererImpl(filter_); | |
46 renderer_->set_host(&host_); | |
47 renderer_->Initialize(decoder_, media::NewExpectedCallback()); | |
48 | |
49 // Run pending tasks and simulate responding with a created audio stream. | |
50 message_loop_->RunAllPending(); | |
51 | |
52 // Duplicate the shared memory handle so both the test and the callee can | |
53 // close their copy. | |
54 base::SharedMemoryHandle duplicated_handle; | |
55 EXPECT_TRUE(shared_mem_.ShareToProcess(base::GetCurrentProcessHandle(), | |
56 &duplicated_handle)); | |
57 | |
58 renderer_->OnCreated(duplicated_handle, kSize); | |
59 } | |
60 | |
61 virtual ~AudioRendererImplTest() { | |
62 } | |
63 | |
64 protected: | |
65 // Fixtures. | |
66 scoped_ptr<MessageLoop> message_loop_; | |
67 scoped_refptr<AudioMessageFilter> filter_; | |
68 base::SharedMemory shared_mem_; | |
69 media::MockFilterHost host_; | |
70 scoped_refptr<media::MockAudioDecoder> decoder_; | |
71 scoped_refptr<AudioRendererImpl> renderer_; | |
72 media::MediaFormat decoder_media_format_; | |
73 | |
74 private: | |
75 DISALLOW_COPY_AND_ASSIGN(AudioRendererImplTest); | |
76 }; | |
77 | |
78 TEST_F(AudioRendererImplTest, SetPlaybackRate) { | |
79 // Execute SetPlaybackRate() codepath to create an IPC message. | |
80 | |
81 // Toggle play/pause to generate some IPC messages. | |
82 renderer_->SetPlaybackRate(0.0f); | |
83 renderer_->SetPlaybackRate(1.0f); | |
84 renderer_->SetPlaybackRate(0.0f); | |
85 | |
86 renderer_->Stop(media::NewExpectedCallback()); | |
87 message_loop_->RunAllPending(); | |
88 } | |
89 | |
90 TEST_F(AudioRendererImplTest, SetVolume) { | |
91 // Execute SetVolume() codepath to create an IPC message. | |
92 renderer_->SetVolume(0.5f); | |
93 renderer_->Stop(media::NewExpectedCallback()); | |
94 message_loop_->RunAllPending(); | |
95 } | |
96 | |
97 TEST_F(AudioRendererImplTest, Stop) { | |
98 // Declare some state messages. | |
99 const ViewMsg_AudioStreamState_Params kError( | |
100 ViewMsg_AudioStreamState_Params::kError); | |
101 const ViewMsg_AudioStreamState_Params kPlaying( | |
102 ViewMsg_AudioStreamState_Params::kPlaying); | |
103 const ViewMsg_AudioStreamState_Params kPaused( | |
104 ViewMsg_AudioStreamState_Params::kPaused); | |
105 | |
106 // Execute Stop() codepath to create an IPC message. | |
107 renderer_->Stop(media::NewExpectedCallback()); | |
108 message_loop_->RunAllPending(); | |
109 | |
110 // Run AudioMessageFilter::Delegate methods, which can be executed after being | |
111 // stopped. AudioRendererImpl shouldn't create any messages. | |
112 renderer_->OnRequestPacket(AudioBuffersState(kSize, 0)); | |
113 renderer_->OnStateChanged(kError); | |
114 renderer_->OnStateChanged(kPlaying); | |
115 renderer_->OnStateChanged(kPaused); | |
116 renderer_->OnCreated(shared_mem_.handle(), kSize); | |
117 renderer_->OnVolume(0.5); | |
118 | |
119 // It's possible that the upstream decoder replies right after being stopped. | |
120 scoped_refptr<media::Buffer> buffer(new media::DataBuffer(kSize)); | |
121 renderer_->ConsumeAudioSamples(buffer); | |
122 } | |
123 | |
124 TEST_F(AudioRendererImplTest, DestroyedMessageLoop_SetPlaybackRate) { | |
125 // Kill the message loop and verify SetPlaybackRate() still works. | |
126 message_loop_.reset(); | |
127 renderer_->SetPlaybackRate(0.0f); | |
128 renderer_->SetPlaybackRate(1.0f); | |
129 renderer_->SetPlaybackRate(0.0f); | |
130 renderer_->Stop(media::NewExpectedCallback()); | |
131 } | |
132 | |
133 TEST_F(AudioRendererImplTest, DestroyedMessageLoop_SetVolume) { | |
134 // Kill the message loop and verify SetVolume() still works. | |
135 message_loop_.reset(); | |
136 renderer_->SetVolume(0.5f); | |
137 renderer_->Stop(media::NewExpectedCallback()); | |
138 } | |
139 | |
140 TEST_F(AudioRendererImplTest, DestroyedMessageLoop_ConsumeAudioSamples) { | |
141 // Kill the message loop and verify OnReadComplete() still works. | |
142 message_loop_.reset(); | |
143 scoped_refptr<media::Buffer> buffer(new media::DataBuffer(kSize)); | |
144 renderer_->ConsumeAudioSamples(buffer); | |
145 renderer_->Stop(media::NewExpectedCallback()); | |
146 } | |
OLD | NEW |