Home | History | Annotate | Download | only in webrtc
      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/memory/scoped_ptr.h"
      6 #include "base/message_loop/message_loop.h"
      7 #include "content/child/child_process.h"
      8 #include "content/renderer/media/media_stream.h"
      9 #include "content/renderer/media/media_stream_audio_source.h"
     10 #include "content/renderer/media/media_stream_video_source.h"
     11 #include "content/renderer/media/media_stream_video_track.h"
     12 #include "content/renderer/media/mock_media_stream_video_source.h"
     13 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
     14 #include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
     15 #include "content/renderer/media/webrtc/webrtc_media_stream_adapter.h"
     16 #include "testing/gtest/include/gtest/gtest.h"
     17 #include "third_party/WebKit/public/platform/WebMediaStream.h"
     18 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
     19 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
     20 #include "third_party/WebKit/public/platform/WebVector.h"
     21 #include "third_party/WebKit/public/web/WebHeap.h"
     22 
     23 namespace content {
     24 
     25 class WebRtcMediaStreamAdapterTest : public ::testing::Test {
     26  public:
     27   virtual void SetUp() {
     28     child_process_.reset(new ChildProcess());
     29     dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
     30   }
     31 
     32   virtual void TearDown() OVERRIDE {
     33     adapter_.reset();
     34     blink::WebHeap::collectAllGarbageForTesting();
     35   }
     36 
     37   blink::WebMediaStream CreateBlinkMediaStream(bool audio, bool video) {
     38     blink::WebVector<blink::WebMediaStreamTrack> audio_track_vector(
     39         audio ? static_cast<size_t>(1) : 0);
     40     if (audio) {
     41       blink::WebMediaStreamSource audio_source;
     42       audio_source.initialize("audio",
     43                               blink::WebMediaStreamSource::TypeAudio,
     44                               "audio");
     45       audio_source.setExtraData(new MediaStreamAudioSource());
     46 
     47       audio_track_vector[0].initialize(audio_source);
     48       MediaStreamTrack* native_track =
     49           new MediaStreamTrack(
     50               WebRtcLocalAudioTrackAdapter::Create(
     51                   audio_track_vector[0].id().utf8(), NULL),
     52                   true);
     53       audio_track_vector[0].setExtraData(native_track);
     54     }
     55 
     56     blink::WebVector<blink::WebMediaStreamTrack> video_track_vector(
     57         video ? static_cast<size_t>(1) : 0);
     58     MediaStreamSource::SourceStoppedCallback dummy_callback;
     59     if (video) {
     60       blink::WebMediaStreamSource video_source;
     61       video_source.initialize("video",
     62                               blink::WebMediaStreamSource::TypeVideo,
     63                               "video");
     64       MediaStreamVideoSource* native_source =
     65           new MockMediaStreamVideoSource(false);
     66       video_source.setExtraData(native_source);
     67       blink::WebMediaConstraints constraints;
     68       constraints.initialize();
     69       video_track_vector[0] = MediaStreamVideoTrack::CreateVideoTrack(
     70           native_source, constraints,
     71           MediaStreamVideoSource::ConstraintsCallback(), true);
     72     }
     73 
     74     blink::WebMediaStream stream_desc;
     75     stream_desc.initialize("media stream",
     76                            audio_track_vector,
     77                            video_track_vector);
     78     stream_desc.setExtraData(new MediaStream(stream_desc));
     79     return stream_desc;
     80   }
     81 
     82   void CreateWebRtcMediaStream(const blink::WebMediaStream& blink_stream,
     83                                size_t expected_number_of_audio_tracks,
     84                                size_t expected_number_of_video_tracks) {
     85     adapter_.reset(new WebRtcMediaStreamAdapter(
     86         blink_stream, dependency_factory_.get()));
     87 
     88     EXPECT_EQ(expected_number_of_audio_tracks,
     89               adapter_->webrtc_media_stream()->GetAudioTracks().size());
     90     EXPECT_EQ(expected_number_of_video_tracks,
     91               adapter_->webrtc_media_stream()->GetVideoTracks().size());
     92     EXPECT_EQ(blink_stream.id().utf8(),
     93               adapter_->webrtc_media_stream()->label());
     94   }
     95 
     96   webrtc::MediaStreamInterface* webrtc_stream() {
     97     return adapter_->webrtc_media_stream();
     98   }
     99 
    100  protected:
    101   base::MessageLoop message_loop_;
    102   scoped_ptr<ChildProcess> child_process_;
    103   scoped_ptr<MockPeerConnectionDependencyFactory> dependency_factory_;
    104   scoped_ptr<WebRtcMediaStreamAdapter> adapter_;
    105 };
    106 
    107 TEST_F(WebRtcMediaStreamAdapterTest, CreateWebRtcMediaStream) {
    108   blink::WebMediaStream blink_stream = CreateBlinkMediaStream(true, true);
    109   CreateWebRtcMediaStream(blink_stream, 1, 1);
    110 }
    111 
    112 // Test that we don't crash if a MediaStream is created in Blink with an unknown
    113 // audio sources. This can happen if a MediaStream is created with
    114 // remote audio track.
    115 TEST_F(WebRtcMediaStreamAdapterTest,
    116        CreateWebRtcMediaStreamWithoutAudioSource) {
    117   // Create a blink MediaStream description.
    118   blink::WebMediaStreamSource audio_source;
    119   audio_source.initialize("audio source",
    120                           blink::WebMediaStreamSource::TypeAudio,
    121                           "something");
    122 
    123   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks(
    124       static_cast<size_t>(1));
    125   audio_tracks[0].initialize(audio_source.id(), audio_source);
    126   blink::WebVector<blink::WebMediaStreamTrack> video_tracks(
    127       static_cast<size_t>(0));
    128 
    129   blink::WebMediaStream blink_stream;
    130   blink_stream.initialize("new stream", audio_tracks, video_tracks);
    131   blink_stream.setExtraData(
    132       new content::MediaStream(blink_stream));
    133   CreateWebRtcMediaStream(blink_stream, 0, 0);
    134 }
    135 
    136 TEST_F(WebRtcMediaStreamAdapterTest, RemoveAndAddTrack) {
    137   blink::WebMediaStream blink_stream = CreateBlinkMediaStream(true, true);
    138   CreateWebRtcMediaStream(blink_stream, 1, 1);
    139 
    140   MediaStream* native_stream = MediaStream::GetMediaStream(blink_stream);
    141 
    142   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
    143   blink_stream.audioTracks(audio_tracks);
    144 
    145   native_stream->RemoveTrack(audio_tracks[0]);
    146   EXPECT_TRUE(webrtc_stream()->GetAudioTracks().empty());
    147 
    148   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
    149   blink_stream.videoTracks(video_tracks);
    150 
    151   native_stream->RemoveTrack(video_tracks[0]);
    152   EXPECT_TRUE(webrtc_stream()->GetVideoTracks().empty());
    153 
    154   native_stream->AddTrack(audio_tracks[0]);
    155   EXPECT_EQ(1u, webrtc_stream()->GetAudioTracks().size());
    156 
    157   native_stream->AddTrack(video_tracks[0]);
    158   EXPECT_EQ(1u, webrtc_stream()->GetVideoTracks().size());
    159 }
    160 
    161 }  // namespace content
    162