content/renderer/media/media_stream_video_capture_source_unittest.cc

   1 // Copyright 2014 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/bind.h"
   6 #include "base/callback_helpers.h"
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/run_loop.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "content/child/child_process.h"
  11 #include "content/public/renderer/media_stream_video_sink.h"
  12 #include "content/renderer/media/media_stream_video_capturer_source.h"
  13 #include "content/renderer/media/media_stream_video_track.h"
  14 #include "content/renderer/media/mock_media_constraint_factory.h"
  15 #include "media/base/bind_to_current_loop.h"
  16 #include "testing/gmock/include/gmock/gmock.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace content {
  20
  21 class MockVideoCapturerDelegate : public VideoCapturerDelegate {
  22  public:
  23   explicit MockVideoCapturerDelegate(const StreamDeviceInfo& device_info)
  24       : VideoCapturerDelegate(device_info) {}
  25
  26   MOCK_METHOD3(StartCapture,
  27                void(const media::VideoCaptureParams& params,
  28                     const VideoCaptureDeliverFrameCB& new_frame_callback,
  29                     const RunningCallback& running_callback));
  30   MOCK_METHOD0(StopCapture, void());
  31
  32  private:
  33   virtual ~MockVideoCapturerDelegate() {}
  34 };
  35
  36 class MediaStreamVideoCapturerSourceTest : public testing::Test {
  37  public:
  38   MediaStreamVideoCapturerSourceTest()
  39      : child_process_(new ChildProcess()),
  40        source_(NULL),
  41        source_stopped_(false) {
  42   }
  43
  44   void InitWithDeviceInfo(const StreamDeviceInfo& device_info) {
  45     delegate_ = new MockVideoCapturerDelegate(device_info);
  46     source_ = new MediaStreamVideoCapturerSource(
  47         device_info,
  48         base::Bind(&MediaStreamVideoCapturerSourceTest::OnSourceStopped,
  49                     base::Unretained(this)),
  50         delegate_);
  51
  52     webkit_source_.initialize(base::UTF8ToUTF16("dummy_source_id"),
  53                               blink::WebMediaStreamSource::TypeVideo,
  54                               base::UTF8ToUTF16("dummy_source_name"));
  55     webkit_source_.setExtraData(source_);
  56   }
  57
  58   blink::WebMediaStreamTrack StartSource() {
  59     MockMediaConstraintFactory factory;
  60     bool enabled = true;
  61     // CreateVideoTrack will trigger OnConstraintsApplied.
  62     return MediaStreamVideoTrack::CreateVideoTrack(
  63         source_, factory.CreateWebMediaConstraints(),
  64         base::Bind(
  65             &MediaStreamVideoCapturerSourceTest::OnConstraintsApplied,
  66             base::Unretained(this)),
  67             enabled);
  68   }
  69
  70   MockVideoCapturerDelegate& mock_delegate() {
  71     return *static_cast<MockVideoCapturerDelegate*>(delegate_.get());
  72   }
  73
  74   void OnSourceStopped(const blink::WebMediaStreamSource& source) {
  75     source_stopped_ =  true;
  76     EXPECT_EQ(source.id(), webkit_source_.id());
  77   }
  78
  79  protected:
  80   void OnConstraintsApplied(MediaStreamSource* source,
  81                             MediaStreamRequestResult result,
  82                             const blink::WebString& result_name) {
  83   }
  84
  85   base::MessageLoopForUI message_loop_;
  86   scoped_ptr<ChildProcess> child_process_;
  87   blink::WebMediaStreamSource webkit_source_;
  88   MediaStreamVideoCapturerSource* source_;  // owned by webkit_source.
  89   scoped_refptr<VideoCapturerDelegate> delegate_;
  90   bool source_stopped_;
  91 };
  92
  93 TEST_F(MediaStreamVideoCapturerSourceTest, TabCaptureAllowResolutionChange) {
  94   StreamDeviceInfo device_info;
  95   device_info.device.type = MEDIA_TAB_VIDEO_CAPTURE;
  96   InitWithDeviceInfo(device_info);
  97
  98   EXPECT_CALL(mock_delegate(), StartCapture(
  99       testing::Field(&media::VideoCaptureParams::allow_resolution_change, true),
 100       testing::_,
 101       testing::_)).Times(1);
 102   blink::WebMediaStreamTrack track = StartSource();
 103   // When the track goes out of scope, the source will be stopped.
 104   EXPECT_CALL(mock_delegate(), StopCapture());
 105 }
 106
 107 TEST_F(MediaStreamVideoCapturerSourceTest,
 108        DesktopCaptureAllowResolutionChange) {
 109   StreamDeviceInfo device_info;
 110   device_info.device.type = MEDIA_DESKTOP_VIDEO_CAPTURE;
 111   InitWithDeviceInfo(device_info);
 112
 113   EXPECT_CALL(mock_delegate(), StartCapture(
 114       testing::Field(&media::VideoCaptureParams::allow_resolution_change, true),
 115       testing::_,
 116       testing::_)).Times(1);
 117   blink::WebMediaStreamTrack track = StartSource();
 118   // When the track goes out of scope, the source will be stopped.
 119   EXPECT_CALL(mock_delegate(), StopCapture());
 120 }
 121
 122 TEST_F(MediaStreamVideoCapturerSourceTest, Ended) {
 123   StreamDeviceInfo device_info;
 124   device_info.device.type = MEDIA_DESKTOP_VIDEO_CAPTURE;
 125   delegate_ = new VideoCapturerDelegate(device_info);
 126   source_ = new MediaStreamVideoCapturerSource(
 127       device_info,
 128       base::Bind(&MediaStreamVideoCapturerSourceTest::OnSourceStopped,
 129                  base::Unretained(this)),
 130       delegate_);
 131   webkit_source_.initialize(base::UTF8ToUTF16("dummy_source_id"),
 132                             blink::WebMediaStreamSource::TypeVideo,
 133                             base::UTF8ToUTF16("dummy_source_name"));
 134   webkit_source_.setExtraData(source_);
 135   blink::WebMediaStreamTrack track = StartSource();
 136   message_loop_.RunUntilIdle();
 137
 138   delegate_->OnStateUpdateOnRenderThread(VIDEO_CAPTURE_STATE_STARTED);
 139   message_loop_.RunUntilIdle();
 140   EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateLive,
 141             webkit_source_.readyState());
 142
 143   EXPECT_FALSE(source_stopped_);
 144   delegate_->OnStateUpdateOnRenderThread(VIDEO_CAPTURE_STATE_ERROR);
 145   message_loop_.RunUntilIdle();
 146   EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateEnded,
 147             webkit_source_.readyState());
 148   // Verify that MediaStreamSource::SourceStoppedCallback has been triggered.
 149   EXPECT_TRUE(source_stopped_);
 150 }
 151
 152 class FakeMediaStreamVideoSink : public MediaStreamVideoSink {
 153  public:
 154   FakeMediaStreamVideoSink(base::TimeTicks* capture_time,
 155                            base::Closure got_frame_cb)
 156       : capture_time_(capture_time),
 157         got_frame_cb_(got_frame_cb) {
 158   }
 159
 160   void OnVideoFrame(const scoped_refptr<media::VideoFrame>& frame,
 161                     const media::VideoCaptureFormat& format,
 162                     const base::TimeTicks& capture_time) {
 163     *capture_time_ = capture_time;
 164     base::ResetAndReturn(&got_frame_cb_).Run();
 165   }
 166
 167  private:
 168   base::TimeTicks* capture_time_;
 169   base::Closure got_frame_cb_;
 170 };
 171
 172 TEST_F(MediaStreamVideoCapturerSourceTest, CaptureTime) {
 173   StreamDeviceInfo device_info;
 174   device_info.device.type = MEDIA_DESKTOP_VIDEO_CAPTURE;
 175   InitWithDeviceInfo(device_info);
 176
 177   VideoCaptureDeliverFrameCB deliver_frame_cb;
 178   VideoCapturerDelegate::RunningCallback running_cb;
 179
 180   EXPECT_CALL(mock_delegate(), StartCapture(
 181       testing::_,
 182       testing::_,
 183       testing::_))
 184       .Times(1)
 185       .WillOnce(testing::DoAll(testing::SaveArg<1>(&deliver_frame_cb),
 186                                testing::SaveArg<2>(&running_cb)));
 187   EXPECT_CALL(mock_delegate(), StopCapture());
 188   blink::WebMediaStreamTrack track = StartSource();
 189   running_cb.Run(MEDIA_DEVICE_OK);
 190
 191   base::RunLoop run_loop;
 192   base::TimeTicks reference_capture_time =
 193       base::TimeTicks::FromInternalValue(60013);
 194   base::TimeTicks capture_time;
 195   FakeMediaStreamVideoSink fake_sink(
 196       &capture_time,
 197       media::BindToCurrentLoop(run_loop.QuitClosure()));
 198   FakeMediaStreamVideoSink::AddToVideoTrack(
 199       &fake_sink,
 200       base::Bind(&FakeMediaStreamVideoSink::OnVideoFrame,
 201                  base::Unretained(&fake_sink)),
 202       track);
 203   child_process_->io_message_loop()->PostTask(
 204       FROM_HERE,
 205       base::Bind(deliver_frame_cb,
 206                  media::VideoFrame::CreateBlackFrame(gfx::Size(2, 2)),
 207                  media::VideoCaptureFormat(),
 208                  reference_capture_time));
 209   run_loop.Run();
 210   FakeMediaStreamVideoSink::RemoveFromVideoTrack(&fake_sink, track);
 211   EXPECT_EQ(reference_capture_time, capture_time);
 212 }
 213
 214 }  // namespace content