content/renderer/media/video_capture_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/memory/shared_memory.h"
   6 #include "content/common/media/video_capture_messages.h"
   7 #include "content/renderer/media/video_capture_message_filter.h"
   8 #include "ipc/ipc_test_sink.h"
   9 #include "media/video/capture/video_capture_types.h"
  10 #include "testing/gmock/include/gmock/gmock.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 using ::testing::_;
  14 using ::testing::AnyNumber;
  15 using ::testing::Mock;
  16 using ::testing::Return;
  17 using ::testing::SaveArg;
  18 using ::testing::StrictMock;
  19
  20 namespace content {
  21 namespace {
  22
  23 class MockVideoCaptureDelegate : public VideoCaptureMessageFilter::Delegate {
  24  public:
  25   MockVideoCaptureDelegate() : device_id_(0) {}
  26
  27   // VideoCaptureMessageFilter::Delegate implementation.
  28   MOCK_METHOD3(OnBufferCreated, void(base::SharedMemoryHandle handle,
  29                                      int length,
  30                                      int buffer_id));
  31   MOCK_METHOD1(OnBufferDestroyed, void(int buffer_id));
  32   MOCK_METHOD3(OnBufferReceived,
  33                void(int buffer_id,
  34                     const media::VideoCaptureFormat& format,
  35                     base::TimeTicks timestamp));
  36   MOCK_METHOD4(OnMailboxBufferReceived,
  37                void(int buffer_id,
  38                     const gpu::MailboxHolder& mailbox_holder,
  39                     const media::VideoCaptureFormat& format,
  40                     base::TimeTicks timestamp));
  41   MOCK_METHOD1(OnStateChanged, void(VideoCaptureState state));
  42   MOCK_METHOD1(OnDeviceSupportedFormatsEnumerated,
  43                void(const media::VideoCaptureFormats& formats));
  44   MOCK_METHOD1(OnDeviceFormatsInUseReceived,
  45                void(const media::VideoCaptureFormats& formats_in_use));
  46
  47   virtual void OnDelegateAdded(int32 device_id) OVERRIDE {
  48     ASSERT_TRUE(device_id != 0);
  49     ASSERT_TRUE(device_id_ == 0);
  50     device_id_ = device_id;
  51   }
  52
  53   int device_id() { return device_id_; }
  54
  55  private:
  56   int device_id_;
  57 };
  58
  59 }  // namespace
  60
  61 TEST(VideoCaptureMessageFilterTest, Basic) {
  62   scoped_refptr<VideoCaptureMessageFilter> filter(
  63       new VideoCaptureMessageFilter());
  64
  65   IPC::TestSink channel;
  66   filter->OnFilterAdded(&channel);
  67   MockVideoCaptureDelegate delegate;
  68   filter->AddDelegate(&delegate);
  69   ASSERT_EQ(1, delegate.device_id());
  70
  71   // VideoCaptureMsg_StateChanged
  72   EXPECT_CALL(delegate, OnStateChanged(VIDEO_CAPTURE_STATE_STARTED));
  73   filter->OnMessageReceived(
  74       VideoCaptureMsg_StateChanged(delegate.device_id(),
  75                                    VIDEO_CAPTURE_STATE_STARTED));
  76   Mock::VerifyAndClearExpectations(&delegate);
  77
  78   // VideoCaptureMsg_NewBuffer
  79   const base::SharedMemoryHandle handle =
  80 #if defined(OS_WIN)
  81       reinterpret_cast<base::SharedMemoryHandle>(10);
  82 #else
  83       base::SharedMemoryHandle(10, true);
  84 #endif
  85   EXPECT_CALL(delegate, OnBufferCreated(handle, 100, 1));
  86   filter->OnMessageReceived(VideoCaptureMsg_NewBuffer(
  87       delegate.device_id(), handle, 100, 1));
  88   Mock::VerifyAndClearExpectations(&delegate);
  89
  90   // VideoCaptureMsg_BufferReady
  91   int buffer_id = 22;
  92   base::TimeTicks timestamp = base::TimeTicks::FromInternalValue(1);
  93
  94   const media::VideoCaptureFormat shm_format(
  95       gfx::Size(234, 512), 30, media::PIXEL_FORMAT_I420);
  96   media::VideoCaptureFormat saved_format;
  97   EXPECT_CALL(delegate, OnBufferReceived(buffer_id, _, timestamp))
  98       .WillRepeatedly(SaveArg<1>(&saved_format));
  99   filter->OnMessageReceived(VideoCaptureMsg_BufferReady(
 100       delegate.device_id(), buffer_id, shm_format, timestamp));
 101   Mock::VerifyAndClearExpectations(&delegate);
 102   EXPECT_EQ(shm_format.frame_size, saved_format.frame_size);
 103   EXPECT_EQ(shm_format.frame_rate, saved_format.frame_rate);
 104   EXPECT_EQ(shm_format.pixel_format, saved_format.pixel_format);
 105
 106   // VideoCaptureMsg_MailboxBufferReady
 107   buffer_id = 33;
 108   timestamp = base::TimeTicks::FromInternalValue(2);
 109
 110   const media::VideoCaptureFormat mailbox_format(
 111       gfx::Size(234, 512), 30, media::PIXEL_FORMAT_TEXTURE);
 112   gpu::Mailbox mailbox;
 113   const int8 mailbox_name[arraysize(mailbox.name)] = "TEST MAILBOX";
 114   mailbox.SetName(mailbox_name);
 115   unsigned int syncpoint = 44;
 116   gpu::MailboxHolder saved_mailbox_holder;
 117   EXPECT_CALL(delegate, OnMailboxBufferReceived(buffer_id, _, _, timestamp))
 118       .WillRepeatedly(
 119            DoAll(SaveArg<1>(&saved_mailbox_holder), SaveArg<2>(&saved_format)));
 120   gpu::MailboxHolder mailbox_holder(mailbox, 0, syncpoint);
 121   filter->OnMessageReceived(
 122       VideoCaptureMsg_MailboxBufferReady(delegate.device_id(),
 123                                          buffer_id,
 124                                          mailbox_holder,
 125                                          mailbox_format,
 126                                          timestamp));
 127   Mock::VerifyAndClearExpectations(&delegate);
 128   EXPECT_EQ(mailbox_format.frame_size, saved_format.frame_size);
 129   EXPECT_EQ(mailbox_format.frame_rate, saved_format.frame_rate);
 130   EXPECT_EQ(mailbox_format.pixel_format, saved_format.pixel_format);
 131   EXPECT_EQ(memcmp(mailbox.name,
 132                    saved_mailbox_holder.mailbox.name,
 133                    sizeof(mailbox.name)),
 134             0);
 135
 136   // VideoCaptureMsg_FreeBuffer
 137   EXPECT_CALL(delegate, OnBufferDestroyed(buffer_id));
 138   filter->OnMessageReceived(VideoCaptureMsg_FreeBuffer(
 139       delegate.device_id(), buffer_id));
 140   Mock::VerifyAndClearExpectations(&delegate);
 141 }
 142
 143 TEST(VideoCaptureMessageFilterTest, Delegates) {
 144   scoped_refptr<VideoCaptureMessageFilter> filter(
 145       new VideoCaptureMessageFilter());
 146
 147   IPC::TestSink channel;
 148   filter->OnFilterAdded(&channel);
 149
 150   StrictMock<MockVideoCaptureDelegate> delegate1;
 151   StrictMock<MockVideoCaptureDelegate> delegate2;
 152
 153   filter->AddDelegate(&delegate1);
 154   filter->AddDelegate(&delegate2);
 155   ASSERT_EQ(1, delegate1.device_id());
 156   ASSERT_EQ(2, delegate2.device_id());
 157
 158   // Send an IPC message. Make sure the correct delegate gets called.
 159   EXPECT_CALL(delegate1, OnStateChanged(VIDEO_CAPTURE_STATE_STARTED));
 160   filter->OnMessageReceived(
 161       VideoCaptureMsg_StateChanged(delegate1.device_id(),
 162                                    VIDEO_CAPTURE_STATE_STARTED));
 163   Mock::VerifyAndClearExpectations(&delegate1);
 164
 165   EXPECT_CALL(delegate2, OnStateChanged(VIDEO_CAPTURE_STATE_STARTED));
 166   filter->OnMessageReceived(
 167       VideoCaptureMsg_StateChanged(delegate2.device_id(),
 168                                    VIDEO_CAPTURE_STATE_STARTED));
 169   Mock::VerifyAndClearExpectations(&delegate2);
 170
 171   // Remove the delegates. Make sure they won't get called.
 172   filter->RemoveDelegate(&delegate1);
 173   filter->OnMessageReceived(
 174       VideoCaptureMsg_StateChanged(delegate1.device_id(),
 175                                    VIDEO_CAPTURE_STATE_ENDED));
 176
 177   filter->RemoveDelegate(&delegate2);
 178   filter->OnMessageReceived(
 179       VideoCaptureMsg_StateChanged(delegate2.device_id(),
 180                                    VIDEO_CAPTURE_STATE_ENDED));
 181 }
 182
 183 TEST(VideoCaptureMessageFilterTest, GetSomeDeviceSupportedFormats) {
 184   scoped_refptr<VideoCaptureMessageFilter> filter(
 185       new VideoCaptureMessageFilter());
 186
 187   IPC::TestSink channel;
 188   filter->OnFilterAdded(&channel);
 189   MockVideoCaptureDelegate delegate;
 190   filter->AddDelegate(&delegate);
 191   ASSERT_EQ(1, delegate.device_id());
 192
 193   EXPECT_CALL(delegate, OnDeviceSupportedFormatsEnumerated(_));
 194   media::VideoCaptureFormats supported_formats;
 195   filter->OnMessageReceived(VideoCaptureMsg_DeviceSupportedFormatsEnumerated(
 196       delegate.device_id(), supported_formats));
 197 }
 198
 199 TEST(VideoCaptureMessageFilterTest, GetSomeDeviceFormatInUse) {
 200   scoped_refptr<VideoCaptureMessageFilter> filter(
 201       new VideoCaptureMessageFilter());
 202
 203   IPC::TestSink channel;
 204   filter->OnFilterAdded(&channel);
 205   MockVideoCaptureDelegate delegate;
 206   filter->AddDelegate(&delegate);
 207   ASSERT_EQ(1, delegate.device_id());
 208
 209   EXPECT_CALL(delegate, OnDeviceFormatsInUseReceived(_));
 210   media::VideoCaptureFormats formats_in_use;
 211   filter->OnMessageReceived(VideoCaptureMsg_DeviceFormatsInUseReceived(
 212       delegate.device_id(), formats_in_use));
 213 }
 214 }  // namespace content