src/content/renderer/media/audio_message_filter_unittest.cc

   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
  11 namespace content {
  12 namespace {
  13
  14 const int kRenderViewId = 1;
  15 const int kRenderFrameId = 2;
  16
  17 class 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
  74 TEST(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
 121 TEST(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