src/content/renderer/media/media_stream_video_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 <string>
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "content/renderer/media/media_stream_video_source.h"
   9 #include "content/renderer/media/mock_media_stream_dependency_factory.h"
  10 #include "media/base/video_frame.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace content {
  14
  15 class DummyMediaStreamVideoSource : public MediaStreamVideoSource {
  16  public:
  17   DummyMediaStreamVideoSource(MediaStreamDependencyFactory* factory)
  18       : MediaStreamVideoSource(factory) {
  19   }
  20
  21   virtual ~DummyMediaStreamVideoSource() {
  22   }
  23
  24   void OnNewFrame(const scoped_refptr<media::VideoFrame>& frame) {
  25     MediaStreamVideoSource::DeliverVideoFrame(frame);
  26   }
  27 };
  28
  29 class MediaStreamVideoSourceTest
  30     : public ::testing::Test {
  31  public:
  32   MediaStreamVideoSourceTest()
  33       : number_of_successful_constraints_applied_(0),
  34         number_of_failed_constraints_applied_(0) {
  35     webkit_source_.initialize(base::UTF8ToUTF16("dummy_source_id"),
  36                               blink::WebMediaStreamSource::TypeVideo,
  37                               base::UTF8ToUTF16("dummy_source_name"));
  38     webkit_source_.setExtraData(new DummyMediaStreamVideoSource(&factory_));
  39   }
  40
  41  protected:
  42   // Create a track that's associated with |webkit_source_|.
  43   blink::WebMediaStreamTrack CreateTrack(
  44       const std::string& id,
  45       const blink::WebMediaConstraints& constraints) {
  46     blink::WebMediaStreamTrack track;
  47     track.initialize(base::UTF8ToUTF16(id), webkit_source_);
  48
  49     DummyMediaStreamVideoSource* source =
  50         static_cast<DummyMediaStreamVideoSource*>(track.source().extraData());
  51
  52     source->AddTrack(track,
  53                      constraints,
  54                      base::Bind(
  55                          &MediaStreamVideoSourceTest::OnConstraintsApplied,
  56                          base::Unretained(this)));
  57     return track;
  58   }
  59
  60   // Simulate that the underlying device start successfully.
  61   void StartSource() {
  62     factory_.last_video_source()->SetLive();
  63   }
  64
  65   // Simulate that the underlying device fail to start.
  66   void FailToStartSource() {
  67     factory_.last_video_source()->SetEnded();
  68   }
  69
  70   void VerifyFrame(int width, int height, int num) {
  71     DummyMediaStreamVideoSource* source =
  72       static_cast<DummyMediaStreamVideoSource*>(webkit_source_.extraData());
  73     MockVideoSource* adapter =
  74         static_cast<MockVideoSource*>(source->GetAdapter());
  75     EXPECT_EQ(width, adapter->GetLastFrameWidth());
  76     EXPECT_EQ(height, adapter->GetLastFrameHeight());
  77     EXPECT_EQ(num, adapter->GetFrameNum());
  78   }
  79
  80   int NumberOfSuccessConstraintsCallbacks() const {
  81     return number_of_successful_constraints_applied_;
  82   }
  83
  84   int NumberOfFailedConstraintsCallbacks() const {
  85     return number_of_failed_constraints_applied_;
  86   }
  87
  88  private:
  89   void OnConstraintsApplied(MediaStreamSource* source, bool success) {
  90     ASSERT_EQ(source, webkit_source_.extraData());
  91
  92     if (success)
  93       ++number_of_successful_constraints_applied_;
  94     else
  95       ++number_of_failed_constraints_applied_;
  96   }
  97
  98   int number_of_successful_constraints_applied_;
  99   int number_of_failed_constraints_applied_;
 100   MockMediaStreamDependencyFactory factory_;
 101   blink::WebMediaStreamSource webkit_source_;
 102 };
 103
 104 TEST_F(MediaStreamVideoSourceTest, AddTrackAndStartAdapter) {
 105   blink::WebMediaConstraints constraints;
 106   blink::WebMediaStreamTrack track = CreateTrack("123", constraints);
 107   StartSource();
 108   EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks());
 109 }
 110
 111 TEST_F(MediaStreamVideoSourceTest, AddTwoTracksBeforeAdapterStart) {
 112   blink::WebMediaConstraints constraints;
 113   blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints);
 114   blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints);
 115   EXPECT_EQ(0, NumberOfSuccessConstraintsCallbacks());
 116   StartSource();
 117   EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks());
 118 }
 119
 120 TEST_F(MediaStreamVideoSourceTest, AddTrackAfterAdapterStart) {
 121   blink::WebMediaConstraints constraints;
 122   blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints);
 123   StartSource();
 124   EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks());
 125   blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints);
 126   EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks());
 127 }
 128
 129 TEST_F(MediaStreamVideoSourceTest, AddTrackAndFailToStartAdapter) {
 130   blink::WebMediaConstraints constraints;
 131   blink::WebMediaStreamTrack track = CreateTrack("123", constraints);
 132   FailToStartSource();
 133   EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks());
 134 }
 135
 136 TEST_F(MediaStreamVideoSourceTest, DeliverVideoFrame) {
 137   blink::WebMediaConstraints constraints;
 138   blink::WebMediaStreamTrack track = CreateTrack("123", constraints);
 139   StartSource();
 140   DummyMediaStreamVideoSource* source =
 141       static_cast<DummyMediaStreamVideoSource*>(track.source().extraData());
 142   VerifyFrame(0, 0, 0);
 143   const int kWidth = 640;
 144   const int kHeight = 480;
 145   scoped_refptr<media::VideoFrame> frame =
 146       media::VideoFrame::CreateBlackFrame(gfx::Size(kWidth, kHeight));
 147   ASSERT_TRUE(frame.get());
 148   source->OnNewFrame(frame);
 149   VerifyFrame(640, 480, 1);
 150   source->OnNewFrame(frame);
 151   VerifyFrame(640, 480, 2);
 152   source->RemoveTrack(track);
 153 }
 154
 155 }  // namespace content