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