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