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   base::SyncSocket::TransitDescriptor socket_descriptor;
  90   const uint32 kLength = 1024;
  91   EXPECT_FALSE(delegate.created_received());
  92   filter->OnMessageReceived(AudioMsg_NotifyStreamCreated(
  93       kStreamId, base::SharedMemory::NULLHandle(), socket_descriptor, kLength));
  94   EXPECT_TRUE(delegate.created_received());
  95   EXPECT_FALSE(base::SharedMemory::IsHandleValid(delegate.handle()));
  96   EXPECT_EQ(kLength, delegate.length());
  97   delegate.Reset();
  98
  99   // AudioMsg_NotifyStreamStateChanged
 100   EXPECT_FALSE(delegate.state_changed_received());
 101   filter->OnMessageReceived(
 102       AudioMsg_NotifyStreamStateChanged(
 103           kStreamId, media::AudioOutputIPCDelegate::kPlaying));
 104   EXPECT_TRUE(delegate.state_changed_received());
 105   EXPECT_EQ(media::AudioOutputIPCDelegate::kPlaying, delegate.state());
 106   delegate.Reset();
 107
 108   message_loop.RunUntilIdle();
 109
 110   ipc->CloseStream();
 111   EXPECT_EQ(static_cast<media::AudioOutputIPCDelegate*>(NULL),
 112             filter->delegates_.Lookup(kStreamId));
 113 }
 114
 115 TEST(AudioMessageFilterTest, Delegates) {
 116   base::MessageLoopForIO message_loop;
 117
 118   scoped_refptr<AudioMessageFilter> filter(new AudioMessageFilter(
 119       message_loop.message_loop_proxy()));
 120
 121   MockAudioDelegate delegate1;
 122   MockAudioDelegate delegate2;
 123   const scoped_ptr<media::AudioOutputIPC> ipc1 =
 124       filter->CreateAudioOutputIPC(kRenderViewId, kRenderFrameId);
 125   const scoped_ptr<media::AudioOutputIPC> ipc2 =
 126       filter->CreateAudioOutputIPC(kRenderViewId, kRenderFrameId);
 127   static const int kSessionId = 0;
 128   ipc1->CreateStream(&delegate1, media::AudioParameters(), kSessionId);
 129   ipc2->CreateStream(&delegate2, media::AudioParameters(), kSessionId);
 130   static const int kStreamId1 = 1;
 131   static const int kStreamId2 = 2;
 132   EXPECT_EQ(&delegate1, filter->delegates_.Lookup(kStreamId1));
 133   EXPECT_EQ(&delegate2, filter->delegates_.Lookup(kStreamId2));
 134
 135   // Send an IPC message. Make sure the correct delegate gets called.
 136   EXPECT_FALSE(delegate1.state_changed_received());
 137   EXPECT_FALSE(delegate2.state_changed_received());
 138   filter->OnMessageReceived(
 139       AudioMsg_NotifyStreamStateChanged(
 140           kStreamId1, media::AudioOutputIPCDelegate::kPlaying));
 141   EXPECT_TRUE(delegate1.state_changed_received());
 142   EXPECT_FALSE(delegate2.state_changed_received());
 143   delegate1.Reset();
 144
 145   EXPECT_FALSE(delegate1.state_changed_received());
 146   EXPECT_FALSE(delegate2.state_changed_received());
 147   filter->OnMessageReceived(
 148       AudioMsg_NotifyStreamStateChanged(
 149           kStreamId2, media::AudioOutputIPCDelegate::kPlaying));
 150   EXPECT_FALSE(delegate1.state_changed_received());
 151   EXPECT_TRUE(delegate2.state_changed_received());
 152   delegate2.Reset();
 153
 154   message_loop.RunUntilIdle();
 155
 156   ipc1->CloseStream();
 157   ipc2->CloseStream();
 158   EXPECT_EQ(static_cast<media::AudioOutputIPCDelegate*>(NULL),
 159             filter->delegates_.Lookup(kStreamId1));
 160   EXPECT_EQ(static_cast<media::AudioOutputIPCDelegate*>(NULL),
 161             filter->delegates_.Lookup(kStreamId2));
 162 }
 163
 164 }  // namespace content