audio_message_filter_unittest.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
1// Copyright (c) 2012 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/message_loop/message_loop.h"
6#include "content/common/media/audio_messages.h"
7#include "content/renderer/media/audio_message_filter.h"
8#include "media/audio/audio_output_ipc.h"
9#include "testing/gtest/include/gtest/gtest.h"
10
11namespace content {
12namespace {
13
14const int kRenderViewId = 1;
15const int kRenderFrameId = 2;
16
17class MockAudioDelegate : public media::AudioOutputIPCDelegate {
18 public:
19  MockAudioDelegate() {
20    Reset();
21  }
22
23  virtual void OnStateChanged(
24      media::AudioOutputIPCDelegate::State state) OVERRIDE {
25    state_changed_received_ = true;
26    state_ = state;
27  }
28
29  virtual void OnStreamCreated(base::SharedMemoryHandle handle,
30                               base::SyncSocket::Handle,
31                               int length) OVERRIDE {
32    created_received_ = true;
33    handle_ = handle;
34    length_ = length;
35  }
36
37  virtual void OnIPCClosed() OVERRIDE {}
38
39  void Reset() {
40    state_changed_received_ = false;
41    state_ = media::AudioOutputIPCDelegate::kError;
42
43    created_received_ = false;
44    handle_ = base::SharedMemory::NULLHandle();
45    length_ = 0;
46
47    volume_received_ = false;
48    volume_ = 0;
49  }
50
51  bool state_changed_received() { return state_changed_received_; }
52  media::AudioOutputIPCDelegate::State state() { return state_; }
53
54  bool created_received() { return created_received_; }
55  base::SharedMemoryHandle handle() { return handle_; }
56  uint32 length() { return length_; }
57
58 private:
59  bool state_changed_received_;
60  media::AudioOutputIPCDelegate::State state_;
61
62  bool created_received_;
63  base::SharedMemoryHandle handle_;
64  int length_;
65
66  bool volume_received_;
67  double volume_;
68
69  DISALLOW_COPY_AND_ASSIGN(MockAudioDelegate);
70};
71
72}  // namespace
73
74TEST(AudioMessageFilterTest, Basic) {
75  base::MessageLoopForIO message_loop;
76
77  scoped_refptr<AudioMessageFilter> filter(new AudioMessageFilter(
78      message_loop.message_loop_proxy()));
79
80  MockAudioDelegate delegate;
81  const scoped_ptr<media::AudioOutputIPC> ipc =
82      filter->CreateAudioOutputIPC(kRenderViewId, kRenderFrameId);
83  static const int kSessionId = 0;
84  ipc->CreateStream(&delegate, media::AudioParameters(), kSessionId);
85  static const int kStreamId = 1;
86  EXPECT_EQ(&delegate, filter->delegates_.Lookup(kStreamId));
87
88  // AudioMsg_NotifyStreamCreated
89#if defined(OS_WIN)
90  base::SyncSocket::Handle socket_handle;
91#else
92  base::FileDescriptor socket_handle;
93#endif
94  const uint32 kLength = 1024;
95  EXPECT_FALSE(delegate.created_received());
96  filter->OnMessageReceived(
97      AudioMsg_NotifyStreamCreated(
98          kStreamId, base::SharedMemory::NULLHandle(),
99          socket_handle, kLength));
100  EXPECT_TRUE(delegate.created_received());
101  EXPECT_FALSE(base::SharedMemory::IsHandleValid(delegate.handle()));
102  EXPECT_EQ(kLength, delegate.length());
103  delegate.Reset();
104
105  // AudioMsg_NotifyStreamStateChanged
106  EXPECT_FALSE(delegate.state_changed_received());
107  filter->OnMessageReceived(
108      AudioMsg_NotifyStreamStateChanged(
109          kStreamId, media::AudioOutputIPCDelegate::kPlaying));
110  EXPECT_TRUE(delegate.state_changed_received());
111  EXPECT_EQ(media::AudioOutputIPCDelegate::kPlaying, delegate.state());
112  delegate.Reset();
113
114  message_loop.RunUntilIdle();
115
116  ipc->CloseStream();
117  EXPECT_EQ(static_cast<media::AudioOutputIPCDelegate*>(NULL),
118            filter->delegates_.Lookup(kStreamId));
119}
120
121TEST(AudioMessageFilterTest, Delegates) {
122  base::MessageLoopForIO message_loop;
123
124  scoped_refptr<AudioMessageFilter> filter(new AudioMessageFilter(
125      message_loop.message_loop_proxy()));
126
127  MockAudioDelegate delegate1;
128  MockAudioDelegate delegate2;
129  const scoped_ptr<media::AudioOutputIPC> ipc1 =
130      filter->CreateAudioOutputIPC(kRenderViewId, kRenderFrameId);
131  const scoped_ptr<media::AudioOutputIPC> ipc2 =
132      filter->CreateAudioOutputIPC(kRenderViewId, kRenderFrameId);
133  static const int kSessionId = 0;
134  ipc1->CreateStream(&delegate1, media::AudioParameters(), kSessionId);
135  ipc2->CreateStream(&delegate2, media::AudioParameters(), kSessionId);
136  static const int kStreamId1 = 1;
137  static const int kStreamId2 = 2;
138  EXPECT_EQ(&delegate1, filter->delegates_.Lookup(kStreamId1));
139  EXPECT_EQ(&delegate2, filter->delegates_.Lookup(kStreamId2));
140
141  // Send an IPC message. Make sure the correct delegate gets called.
142  EXPECT_FALSE(delegate1.state_changed_received());
143  EXPECT_FALSE(delegate2.state_changed_received());
144  filter->OnMessageReceived(
145      AudioMsg_NotifyStreamStateChanged(
146          kStreamId1, media::AudioOutputIPCDelegate::kPlaying));
147  EXPECT_TRUE(delegate1.state_changed_received());
148  EXPECT_FALSE(delegate2.state_changed_received());
149  delegate1.Reset();
150
151  EXPECT_FALSE(delegate1.state_changed_received());
152  EXPECT_FALSE(delegate2.state_changed_received());
153  filter->OnMessageReceived(
154      AudioMsg_NotifyStreamStateChanged(
155          kStreamId2, media::AudioOutputIPCDelegate::kPlaying));
156  EXPECT_FALSE(delegate1.state_changed_received());
157  EXPECT_TRUE(delegate2.state_changed_received());
158  delegate2.Reset();
159
160  message_loop.RunUntilIdle();
161
162  ipc1->CloseStream();
163  ipc2->CloseStream();
164  EXPECT_EQ(static_cast<media::AudioOutputIPCDelegate*>(NULL),
165            filter->delegates_.Lookup(kStreamId1));
166  EXPECT_EQ(static_cast<media::AudioOutputIPCDelegate*>(NULL),
167            filter->delegates_.Lookup(kStreamId2));
168}
169
170}  // namespace content
171