src/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::AllOf;
  15 using ::testing::AnyNumber;
  16 using ::testing::Field;
  17 using ::testing::Mock;
  18 using ::testing::Return;
  19 using ::testing::StrictMock;
  20
  21 namespace content {
  22 namespace {
  23
  24 class MockVideoCaptureDelegate : public VideoCaptureMessageFilter::Delegate {
  25  public:
  26   MockVideoCaptureDelegate() : device_id_(0) {}
  27
  28   // VideoCaptureMessageFilter::Delegate implementation.
  29   MOCK_METHOD3(OnBufferCreated, void(base::SharedMemoryHandle handle,
  30                                      int length,
  31                                      int buffer_id));
  32   MOCK_METHOD1(OnBufferDestroyed, void(int buffer_id));
  33   MOCK_METHOD3(OnBufferReceived, void(int buffer_id,
  34                                       base::Time timestamp,
  35                                       const media::VideoCaptureFormat& format));
  36   MOCK_METHOD1(OnStateChanged, void(VideoCaptureState state));
  37
  38   virtual void OnDelegateAdded(int32 device_id) OVERRIDE {
  39     ASSERT_TRUE(device_id != 0);
  40     ASSERT_TRUE(device_id_ == 0);
  41     device_id_ = device_id;
  42   }
  43
  44   int device_id() { return device_id_; }
  45
  46  private:
  47   int device_id_;
  48 };
  49
  50 }  // namespace
  51
  52 TEST(VideoCaptureMessageFilterTest, Basic) {
  53   scoped_refptr<VideoCaptureMessageFilter> filter(
  54       new VideoCaptureMessageFilter());
  55
  56   IPC::TestSink channel;
  57   filter->OnFilterAdded(&channel);
  58   MockVideoCaptureDelegate delegate;
  59   filter->AddDelegate(&delegate);
  60   ASSERT_EQ(1, delegate.device_id());
  61
  62   // VideoCaptureMsg_StateChanged
  63   EXPECT_CALL(delegate, OnStateChanged(VIDEO_CAPTURE_STATE_STARTED));
  64   filter->OnMessageReceived(
  65       VideoCaptureMsg_StateChanged(delegate.device_id(),
  66                                    VIDEO_CAPTURE_STATE_STARTED));
  67   Mock::VerifyAndClearExpectations(&delegate);
  68
  69   // VideoCaptureMsg_NewBuffer
  70   const base::SharedMemoryHandle handle =
  71 #if defined(OS_WIN)
  72       reinterpret_cast<base::SharedMemoryHandle>(10);
  73 #else
  74       base::SharedMemoryHandle(10, true);
  75 #endif
  76   EXPECT_CALL(delegate, OnBufferCreated(handle, 100, 1));
  77   filter->OnMessageReceived(VideoCaptureMsg_NewBuffer(
  78       delegate.device_id(), handle, 100, 1));
  79   Mock::VerifyAndClearExpectations(&delegate);
  80
  81   // VideoCaptureMsg_BufferReady
  82   int buffer_id = 22;
  83   base::Time timestamp = base::Time::FromInternalValue(1);
  84
  85   media::VideoCaptureFormat format(234, 512, 30,
  86       media::ConstantResolutionVideoCaptureDevice);
  87   EXPECT_CALL(delegate, OnBufferReceived(buffer_id, timestamp,
  88       AllOf(Field(&media::VideoCaptureFormat::width, 234),
  89             Field(&media::VideoCaptureFormat::height, 512),
  90             Field(&media::VideoCaptureFormat::frame_rate, 30))));
  91   filter->OnMessageReceived(VideoCaptureMsg_BufferReady(
  92       delegate.device_id(), buffer_id, timestamp, format));
  93   Mock::VerifyAndClearExpectations(&delegate);
  94
  95   // VideoCaptureMsg_FreeBuffer
  96   EXPECT_CALL(delegate, OnBufferDestroyed(buffer_id));
  97   filter->OnMessageReceived(VideoCaptureMsg_FreeBuffer(
  98       delegate.device_id(), buffer_id));
  99   Mock::VerifyAndClearExpectations(&delegate);
 100 }
 101
 102 TEST(VideoCaptureMessageFilterTest, Delegates) {
 103   scoped_refptr<VideoCaptureMessageFilter> filter(
 104       new VideoCaptureMessageFilter());
 105
 106   IPC::TestSink channel;
 107   filter->OnFilterAdded(&channel);
 108
 109   StrictMock<MockVideoCaptureDelegate> delegate1;
 110   StrictMock<MockVideoCaptureDelegate> delegate2;
 111
 112   filter->AddDelegate(&delegate1);
 113   filter->AddDelegate(&delegate2);
 114   ASSERT_EQ(1, delegate1.device_id());
 115   ASSERT_EQ(2, delegate2.device_id());
 116
 117   // Send an IPC message. Make sure the correct delegate gets called.
 118   EXPECT_CALL(delegate1, OnStateChanged(VIDEO_CAPTURE_STATE_STARTED));
 119   filter->OnMessageReceived(
 120       VideoCaptureMsg_StateChanged(delegate1.device_id(),
 121                                    VIDEO_CAPTURE_STATE_STARTED));
 122   Mock::VerifyAndClearExpectations(&delegate1);
 123
 124   EXPECT_CALL(delegate2, OnStateChanged(VIDEO_CAPTURE_STATE_STARTED));
 125   filter->OnMessageReceived(
 126       VideoCaptureMsg_StateChanged(delegate2.device_id(),
 127                                    VIDEO_CAPTURE_STATE_STARTED));
 128   Mock::VerifyAndClearExpectations(&delegate2);
 129
 130   // Remove the delegates. Make sure they won't get called.
 131   filter->RemoveDelegate(&delegate1);
 132   filter->OnMessageReceived(
 133       VideoCaptureMsg_StateChanged(delegate1.device_id(),
 134                                    VIDEO_CAPTURE_STATE_ENDED));
 135
 136   filter->RemoveDelegate(&delegate2);
 137   filter->OnMessageReceived(
 138       VideoCaptureMsg_StateChanged(delegate2.device_id(),
 139                                    VIDEO_CAPTURE_STATE_ENDED));
 140 }
 141
 142 }  // namespace content