src/content/renderer/media/media_stream_dependency_factory_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/scoped_ptr.h"
   6 #include "content/common/media/media_stream_options.h"
   7 #include "content/renderer/media/media_stream_audio_source.h"
   8 #include "content/renderer/media/media_stream_extra_data.h"
   9 #include "content/renderer/media/media_stream_video_source.h"
  10 #include "content/renderer/media/mock_media_stream_dependency_factory.h"
  11 #include "content/renderer/media/mock_web_rtc_peer_connection_handler_client.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
  14 #include "third_party/WebKit/public/platform/WebMediaStream.h"
  15 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
  16 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
  17 #include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandler.h"
  18 #include "third_party/WebKit/public/platform/WebVector.h"
  19
  20 namespace content {
  21
  22 class MediaSourceCreatedObserver {
  23  public:
  24   MediaSourceCreatedObserver()
  25      : result_(false),
  26        description_(NULL) {
  27   }
  28
  29   void OnCreateNativeSourcesComplete(
  30       blink::WebMediaStream* description,
  31       bool request_succeeded) {
  32     result_ = request_succeeded;
  33     description_ = description;
  34   }
  35
  36   blink::WebMediaStream* description() const {
  37     return description_;
  38   }
  39   bool result() const { return result_; }
  40
  41  private:
  42   bool result_;
  43   blink::WebMediaStream* description_;
  44 };
  45
  46 class MediaStreamDependencyFactoryTest : public ::testing::Test {
  47  public:
  48   virtual void SetUp() {
  49     dependency_factory_.reset(new MockMediaStreamDependencyFactory());
  50   }
  51
  52   blink::WebMediaStream CreateWebKitMediaStream(bool audio, bool video) {
  53     blink::WebVector<blink::WebMediaStreamSource> audio_sources(
  54         audio ? static_cast<size_t>(1) : 0);
  55     blink::WebVector<blink::WebMediaStreamSource> video_sources(
  56         video ? static_cast<size_t>(1) : 0);
  57     MediaStreamSource::SourceStoppedCallback dummy_callback;
  58
  59     if (audio) {
  60       StreamDeviceInfo info;
  61       info.device.type = content::MEDIA_DEVICE_AUDIO_CAPTURE;
  62       info.device.name = "audio";
  63       info.session_id = 99;
  64       audio_sources[0].initialize("audio",
  65                                   blink::WebMediaStreamSource::TypeAudio,
  66                                   "audio");
  67       audio_sources[0].setExtraData(
  68           new MediaStreamAudioSource());
  69       audio_sources_.assign(audio_sources);
  70     }
  71     if (video) {
  72       StreamDeviceInfo info;
  73       info.device.type = content::MEDIA_DEVICE_VIDEO_CAPTURE;
  74       info.device.name = "video";
  75       info.session_id = 98;
  76       video_sources[0].initialize("video",
  77                                   blink::WebMediaStreamSource::TypeVideo,
  78                                   "video");
  79       video_sources[0].setExtraData(
  80           new MediaStreamVideoSource(dependency_factory_.get()));
  81       video_sources_.assign(video_sources);
  82     }
  83     blink::WebMediaStream stream_desc;
  84     blink::WebVector<blink::WebMediaStreamTrack> audio_track_vector(
  85         audio_sources.size());
  86     for (size_t i = 0; i < audio_track_vector.size(); ++i) {
  87       audio_track_vector[i].initialize(audio_sources[i].id(),
  88                                        audio_sources[i]);
  89     }
  90
  91     blink::WebVector<blink::WebMediaStreamTrack> video_track_vector(
  92         video_sources.size());
  93     for (size_t i = 0; i < video_track_vector.size(); ++i) {
  94       video_track_vector[i].initialize(video_sources[i].id(),
  95                                        video_sources[i]);
  96     }
  97
  98     stream_desc.initialize("media stream", audio_track_vector,
  99                            video_track_vector);
 100     return stream_desc;
 101   }
 102
 103   void VerifyMediaStream(const blink::WebMediaStream& stream_desc,
 104                          size_t num_audio_tracks,
 105                          size_t num_video_tracks) {
 106     content::MediaStreamExtraData* extra_data =
 107         static_cast<content::MediaStreamExtraData*>(stream_desc.extraData());
 108     ASSERT_TRUE(extra_data && extra_data->stream().get());
 109     EXPECT_TRUE(extra_data->is_local());
 110     EXPECT_EQ(num_audio_tracks, extra_data->stream()->GetAudioTracks().size());
 111     EXPECT_EQ(num_video_tracks, extra_data->stream()->GetVideoTracks().size());
 112   }
 113
 114  protected:
 115   scoped_ptr<MockMediaStreamDependencyFactory> dependency_factory_;
 116   blink::WebVector<blink::WebMediaStreamSource> audio_sources_;
 117   blink::WebVector<blink::WebMediaStreamSource> video_sources_;
 118 };
 119
 120 TEST_F(MediaStreamDependencyFactoryTest, CreateRTCPeerConnectionHandler) {
 121   MockWebRTCPeerConnectionHandlerClient client_jsep;
 122   scoped_ptr<blink::WebRTCPeerConnectionHandler> pc_handler(
 123       dependency_factory_->CreateRTCPeerConnectionHandler(&client_jsep));
 124   EXPECT_TRUE(pc_handler.get() != NULL);
 125 }
 126
 127 TEST_F(MediaStreamDependencyFactoryTest, CreateNativeMediaStream) {
 128   blink::WebMediaStream stream_desc = CreateWebKitMediaStream(true, true);
 129
 130   dependency_factory_->CreateNativeLocalMediaStream(&stream_desc);
 131   VerifyMediaStream(stream_desc, 1, 1);
 132 }
 133
 134 // Test that we don't crash if a MediaStream is created in WebKit with unknown
 135 // sources. This can for example happen if a MediaStream is created with
 136 // remote tracks.
 137 TEST_F(MediaStreamDependencyFactoryTest, CreateNativeMediaStreamWithoutSource) {
 138   // Create a WebKit MediaStream description.
 139   blink::WebMediaStreamSource audio_source;
 140   audio_source.initialize("audio source",
 141                           blink::WebMediaStreamSource::TypeAudio,
 142                           "something");
 143   blink::WebMediaStreamSource video_source;
 144   video_source.initialize("video source",
 145                           blink::WebMediaStreamSource::TypeVideo,
 146                           "something");
 147
 148   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks(
 149       static_cast<size_t>(1));
 150   audio_tracks[0].initialize(audio_source.id(), audio_source);
 151   blink::WebVector<blink::WebMediaStreamTrack> video_tracks(
 152       static_cast<size_t>(1));
 153   video_tracks[0].initialize(video_source.id(), video_source);
 154
 155   blink::WebMediaStream stream_desc;
 156   stream_desc.initialize("new stream", audio_tracks, video_tracks);
 157
 158   dependency_factory_->CreateNativeLocalMediaStream(&stream_desc);
 159   VerifyMediaStream(stream_desc, 0, 0);
 160 }
 161
 162 TEST_F(MediaStreamDependencyFactoryTest, AddAndRemoveNativeTrack) {
 163   blink::WebMediaStream stream_desc = CreateWebKitMediaStream(true, true);
 164
 165   dependency_factory_->CreateNativeLocalMediaStream(&stream_desc);
 166   VerifyMediaStream(stream_desc, 1, 1);
 167
 168   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
 169   stream_desc.audioTracks(audio_tracks);
 170   EXPECT_TRUE(dependency_factory_->RemoveNativeMediaStreamTrack(
 171       stream_desc, audio_tracks[0]));
 172   VerifyMediaStream(stream_desc, 0, 1);
 173
 174   EXPECT_TRUE(dependency_factory_->AddNativeMediaStreamTrack(
 175       stream_desc, audio_tracks[0]));
 176   VerifyMediaStream(stream_desc, 1, 1);
 177
 178   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
 179   stream_desc.videoTracks(video_tracks);
 180   EXPECT_TRUE(dependency_factory_->RemoveNativeMediaStreamTrack(
 181       stream_desc, video_tracks[0]));
 182   VerifyMediaStream(stream_desc, 1, 0);
 183
 184   EXPECT_TRUE(dependency_factory_->AddNativeMediaStreamTrack(
 185       stream_desc, video_tracks[0]));
 186   VerifyMediaStream(stream_desc, 1, 1);
 187 }
 188
 189 }  // namespace content